moblues 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d306b405a86b2290eb6c2526748df8fe10a0f8b3
+  data.tar.gz: b598e9094d9add99dc8255adb304ac42e07e7102
+SHA512:
+  metadata.gz: 81b7c225fa7822b7030dcdab5088047bd7be37d5ca78d55e87c3f7a1b02e3edc1d9166036aa8e6645049bb935c7b432611829d9d0b11093c12f1f4432873deac
+  data.tar.gz: 7aa8db60830f0cbb8d810c17901f1c8b0c9dc11b30088c48a9cc5bc2f10dab6d69c89f241779f216148ae5b243eb5b1ac99547d53d3b68c063ecbb5b413ee2e1

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.idea/
+.DS_Store

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 1.9.3
+script: bundle exec rake spec
+addons:
+    code_climate:
+        repo_token: 97374e550763cfe3be1c90ba93d9ea9e5b4ea47e1dead9b554f5f4a18b3a6f75

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Vincent Garrigues
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,44 @@
+# Moblues [![Build Status](https://magnum.travis-ci.com/garriguv/moblues.svg?token=GCky67DnySmgxHiFqjq3&branch=master)](https://magnum.travis-ci.com/garriguv/moblues) [![Code Climate](https://codeclimate.com/repos/547ac5cfe30ba05abc1d6329/badges/3c5aba53610a96394d9f/gpa.svg)](https://codeclimate.com/repos/547ac5cfe30ba05abc1d6329/feed) [![Test Coverage](https://codeclimate.com/repos/547ac5cfe30ba05abc1d6329/badges/3c5aba53610a96394d9f/coverage.svg)](https://codeclimate.com/repos/547ac5cfe30ba05abc1d6329/feed)
+
+Generates files for entities defined in a Core Data model. Inspired by [mogenerator](https://github.com/rentzsch/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 shouldn't be modified. Moblues will only create the human file if it doesn't exist.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'moblues'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install moblues
+
+## Usage
+
+```
+Usage:
+  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
+
+generate the machine and human files
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/garriguv/moblues/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+6. You're awesome! :+1:

data/Rakefile

@@ -0,0 +1,4 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new

data/bin/moblues

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'moblues/cli'
+
+Moblues::CLI.start(ARGV)

data/lib/extensions/hash.rb

@@ -0,0 +1,9 @@
+class Hash
+  def compact
+    select { |_,v| !v.nil? }
+  end
+
+  def compact!
+    select! { |_,v| !v.nil? }
+  end
+end

data/lib/moblues/cli.rb

@@ -0,0 +1,26 @@
+require 'thor'
+require 'moblues/reader/model'
+require 'moblues/generator/model'
+
+module Moblues
+  class CLI < Thor
+    desc 'generate', 'generate the machine and human files'
+    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'
+    def generate
+      mkdir([options[:human], options[:machine]])
+      reader = Moblues::Reader::Model.new
+      generator = Moblues::Generator::Model.new(human_dir: options[:human], machine_dir: options[:machine])
+      entities = reader.model(options[:model])
+      generator.generate(entities)
+    end
+
+    private
+    def mkdir(dirs)
+      dirs.each do |dir|
+        Dir.mkdir(dir) unless Dir.exists?(dir)
+      end
+    end
+  end
+end

data/lib/moblues/data_model/attribute.rb

@@ -0,0 +1,15 @@
+require 'extensions/hash'
+
+module Moblues
+  module DataModel
+    class Attribute < Struct.new(:name, :type)
+      def initialize(params)
+        p = params.compact
+        super(
+          p.fetch(:name),
+          p.fetch(:type)
+        )
+      end
+    end
+  end
+end

data/lib/moblues/data_model/entity.rb

@@ -0,0 +1,17 @@
+require 'extensions/hash'
+
+module Moblues
+  module DataModel
+    class Entity < Struct.new(:name, :parent_entity, :attributes, :relationships)
+      def initialize(params)
+        p = params.compact
+        super(
+          p.fetch(:name),
+          p.fetch(:parent_entity, 'NSManagedObject'),
+          p.fetch(:attributes, []),
+          p.fetch(:relationships, [])
+        )
+      end
+    end
+  end
+end

data/lib/moblues/data_model/relationship.rb

@@ -0,0 +1,17 @@
+require 'extensions/hash'
+
+module Moblues
+  module DataModel
+    class Relationship < Struct.new(:name, :destination_entity, :to_many, :ordered)
+      def initialize(params)
+        p = params.compact
+        super(
+          p.fetch(:name),
+          p.fetch(:destination_entity),
+          p.fetch(:to_many, false),
+          p.fetch(:ordered, false)
+        )
+      end
+    end
+  end
+end

data/lib/moblues/data_model.rb

@@ -0,0 +1,3 @@
+require 'moblues/data_model/attribute'
+require 'moblues/data_model/entity'
+require 'moblues/data_model/relationship'

data/lib/moblues/generator/base.rb

@@ -0,0 +1,65 @@
+require 'erb'
+require 'moblues/reader/type'
+
+module Moblues
+  module Generator
+    class Base
+      def initialize(params)
+        @output_dir = params.fetch(:output_dir)
+      end
+
+      protected
+      attr_reader :output_dir
+
+      def write_header(entity)
+        write_file(header_file(entity), header(entity))
+      end
+
+      def write_implementation(entity)
+        write_file(implementation_file(entity), implementation(entity))
+      end
+
+      def write_file(file, text)
+        File.open(file, 'w+') do |f|
+          f.write(text)
+        end
+      end
+
+      def header_file(entity)
+        File.join(output_dir, format_name(entity, 'h'))
+      end
+
+      def implementation_file(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

data/lib/moblues/generator/human.rb

@@ -0,0 +1,25 @@
+require 'moblues/generator/base'
+
+module Moblues
+  module Generator
+    class Human < Base
+      def generate(entity)
+        write_header(entity) unless File.exists?(header_file(entity))
+        write_implementation(entity) unless File.exists?(implementation_file(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

data/lib/moblues/generator/human_header.h.erb

@@ -0,0 +1,4 @@
+#import "_<%= entity.name %>.h"
+
+@interface <%= entity.name %> : _<%= entity.name %>
+@end

data/lib/moblues/generator/human_implementation.m.erb

@@ -0,0 +1,4 @@
+#import "<%= entity.name %>.h"
+
+@implementation <%= entity.name %>
+@end

data/lib/moblues/generator/machine.rb

@@ -0,0 +1,36 @@
+require 'moblues/generator/base'
+
+module Moblues
+  module Generator
+    class Machine < Base
+      def initialize(params)
+        @type_reader = Reader::Type.new
+        super(params)
+      end
+
+      def generate(entity)
+        write_header(entity)
+        write_implementation(entity)
+      end
+
+      private
+      attr_reader :type_reader
+
+      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

data/lib/moblues/generator/machine_header.h.erb

@@ -0,0 +1,43 @@
+#import <%= '<Foundation/Foundation.h>' %>
+#import <%= '<CoreData/CoreData.h>' %>
+<% if entity.parent_entity != 'NSManagedObject' -%>
+
+#import "<%= entity.parent_entity %>.h"
+<% end -%>
+
+<% for class_name in entity.relationships.map { |rel| rel.destination_entity }.uniq -%>
+@class <%= class_name %>;
+<% end -%>
+
+@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 %>;
+<% end -%>
+
+<% for relationship in entity.relationships -%>
+@property (nonatomic, strong) <%= type_reader.relationship_type(relationship) %><%= relationship.name %>;
+<% end -%>
+@end
+<% if !entity.relationships.select { |e| e.to_many }.empty? %>
+@interface _<%= entity.name %> (CoreDataGeneratedAccessors)
+<% for relationship in entity.relationships.select { |e| e.to_many } %>
+<% if relationship.ordered -%>
+- (void)insertObject:(<%= relationship.destination_entity %> *)value in<%= capitalized_name(relationship) %>AtIndex:(NSUInteger)index;
+- (void)removeObjectFrom<%= capitalized_name(relationship) %>AtIndex:(NSUInteger)index;
+- (void)insert<%= capitalized_name(relationship) %>:(NSArray *)values atIndexes:(NSIndexSet *)indexes;
+- (void)remove<%= capitalized_name(relationship) %>AtIndexes:(NSIndexSet *)indexes;
+- (void)replaceObjectIn<%= capitalized_name(relationship) %>AtIndex:(NSUInteger)index withObject:(<%= relationship.destination_entity %> *)value;
+- (void)replace<%= capitalized_name(relationship) %>AtIndexes:(NSIndexSet *)indexes with<%= capitalized_name(relationship) %>:(NSArray *)values;
+- (void)add<%= capitalized_name(relationship) %>Object:(<%= relationship.destination_entity %> *)value;
+- (void)remove<%= capitalized_name(relationship) %>Object:(<%= relationship.destination_entity %> *)value;
+- (void)add<%= capitalized_name(relationship) %>:(NSOrderedSet *)values;
+- (void)remove<%= capitalized_name(relationship) %>:(NSOrderedSet *)values;
+<% else -%>
+- (void)add<%= capitalized_name(relationship) %>Object:(<%= relationship.destination_entity %> *)value;
+- (void)remove<%= capitalized_name(relationship) %>Object:(<%= relationship.destination_entity %> *)value;
+- (void)add<%= capitalized_name(relationship) %>:(NSSet *)values;
+- (void)remove<%= capitalized_name(relationship) %>:(NSSet *)values;
+<% end -%>
+<% end %>
+@end
+<% end -%>

data/lib/moblues/generator/machine_implementation.m.erb

@@ -0,0 +1,7 @@
+#import "<%= '_' + entity.name %>.h"
+
+@implementation <%= '_' + entity.name %>
+<% for property in entity.attributes + entity.relationships -%>
+@dynamic <%= property.name %>;
+<% end -%>
+@end

data/lib/moblues/generator/model.rb

@@ -0,0 +1,23 @@
+require 'moblues/generator/machine'
+require 'moblues/generator/human'
+
+module Moblues
+  module Generator
+    class Model
+      def initialize(params)
+        @human = Human.new(output_dir: params.fetch(:human_dir))
+        @machine = Machine.new(output_dir: params.fetch(:machine_dir))
+      end
+
+      def generate(entities)
+        entities.each do |entity|
+          human.generate(entity)
+          machine.generate(entity)
+        end
+      end
+
+      private
+      attr_reader :human, :machine
+    end
+  end
+end

data/lib/moblues/generator.rb

@@ -0,0 +1,4 @@
+require 'moblues/generator/base'
+require 'moblues/generator/model'
+require 'moblues/generator/machine'
+require 'moblues/generator/human'

data/lib/moblues/reader/attribute.rb

@@ -0,0 +1,23 @@
+require 'rexml/document'
+require 'moblues/data_model/attribute'
+require 'moblues/reader/type'
+
+module Moblues
+  module Reader
+    class Attribute
+      def initialize
+        @type_reader = Type.new
+      end
+
+      def attribute(xml)
+       DataModel::Attribute.new(
+         name: xml.attributes['name'],
+         type: type_reader.map_type_str(xml.attributes['attributeType'])
+       )
+      end
+
+      private
+      attr_reader :type_reader
+    end
+  end
+end

data/lib/moblues/reader/entity.rb

@@ -0,0 +1,34 @@
+require 'rexml/document'
+require 'moblues/reader/attribute'
+require 'moblues/reader/relationship'
+require 'moblues/data_model/entity'
+
+module Moblues
+  module Reader
+    class Entity
+      def initialize(params = defaults)
+        @attribute_reader = params[:attribute_reader]
+        @relationship_reader = params[:relationship_reader]
+      end
+
+      def entity(xml)
+        attributes = xml.elements.to_a('attribute').map { |xml_attr| attribute_reader.attribute(xml_attr) }
+        relationships = xml.elements.to_a('relationship').map { |xml_rel| relationship_reader.relationship(xml_rel) }
+        DataModel::Entity.new(name: xml.attributes['name'],
+                              parent_entity: xml.attributes['parentEntity'],
+                              attributes: attributes,
+                              relationships: relationships)
+      end
+
+      private
+      attr_reader :attribute_reader, :relationship_reader
+
+      def defaults
+        {
+          attribute_reader: Attribute.new,
+          relationship_reader: Relationship.new
+        }
+      end
+    end
+  end
+end

data/lib/moblues/reader/model.rb

@@ -0,0 +1,31 @@
+require 'rexml/document'
+require 'moblues/utils/model_resolver'
+require 'moblues/reader/entity'
+
+module Moblues
+  module Reader
+    class Model
+      def initialize(params = defaults)
+        @model_resolver = params[:resolver]
+        @entity_reader = params[:reader]
+      end
+
+      def model(path)
+        raise ArgumentError unless path
+        content_path = model_resolver.resolve_model(path)
+        xml = REXML::Document.new(File.read(content_path))
+        xml.root.elements.to_a('entity').map { |entity| entity_reader.entity(entity) }
+      end
+
+      private
+      attr_reader :model_resolver, :entity_reader
+
+      def defaults
+        {
+          resolver: Utils::ModelResolver.new,
+          reader:   Entity.new
+        }
+      end
+    end
+  end
+end

data/lib/moblues/reader/relationship.rb

@@ -0,0 +1,22 @@
+require 'rexml/document'
+require 'moblues/data_model/relationship'
+
+module Moblues
+  module Reader
+    class Relationship
+      def relationship(xml)
+        DataModel::Relationship.new(
+          name: xml.attributes['name'],
+          destination_entity: xml.attributes['destinationEntity'],
+          to_many: opt_bool(xml.attributes['toMany']),
+          ordered: opt_bool(xml.attributes['ordered'])
+        )
+      end
+
+      private
+      def opt_bool(str_value)
+        str_value == 'YES'
+      end
+    end
+  end
+end

data/lib/moblues/reader/type.rb

@@ -0,0 +1,58 @@
+module Moblues
+  module Reader
+    class Type
+      def map_type_str(type_str)
+        case type_str
+        when 'String'
+          :string
+        when 'Integer 16', 'Integer 32', 'Integer 64', 'Boolean'
+          :number
+        when 'Date'
+          :date
+        when 'Binary'
+          :data
+        when 'Transformable'
+          :id
+        else
+          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/reader.rb

@@ -0,0 +1,5 @@
+require 'moblues/reader/model'
+require 'moblues/reader/attribute'
+require 'moblues/reader/entity'
+require 'moblues/reader/relationship'
+require 'moblues/reader/type'

data/lib/moblues/utils/model_resolver.rb

@@ -0,0 +1,19 @@
+require 'plist'
+
+module Moblues
+  module Utils
+    class ModelResolver
+      def resolve_model(path)
+        raise ArgumentError, "#{path} not found" unless path && File.directory?(path)
+        File.join(path, model_version(path), 'contents')
+      end
+
+      private
+
+      def model_version(model_path)
+        xml = File.open(File.join(model_path, '.xccurrentversion')).read
+        Plist::parse_xml(xml)['_XCCurrentVersionName']
+      end
+    end
+  end
+end

data/lib/moblues/version.rb

@@ -0,0 +1,3 @@
+module Moblues
+  VERSION = '0.0.1'
+end

data/lib/moblues.rb

@@ -0,0 +1,4 @@
+require 'moblues/version'
+require 'moblues/data_model'
+require 'moblues/reader'
+require 'moblues/generator'