immutabler 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 082cae15547802583d920c85a676e4c5cf93302d
+  data.tar.gz: 0c607875a8e602d62a7d68b747279f86175f48fd
+SHA512:
+  metadata.gz: a98dccfbf117a51d37156630bb5346bdf79d302a2b7fbc43d3d0991ef8aa52709f0aea5470ecc41753212d58b7a07daac70c8fe034366033491eb77d04a65d93
+  data.tar.gz: 2da0f6044560cc729c7466b0767d43e2cfbdee32fcdcbbc2f7d3cb725f0f6126d0b5c48483d657bebc240e811f26dc143bcdfb4e7673731b1adcf3b59320f022

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/.idea/
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.1.3
+before_install: gem install bundler -v 1.10.6

data/GETTING_STARTED.md

@@ -0,0 +1,194 @@
+Getting Started
+====================
+
+# Syntax
+
+##Groups
+
+Groups are on the root level
+
+```ruby
+Immutabler.group :GroupName do
+  output_dir('./project/output')
+  prefix('GroupPrefix')
+  base_model('NSObject')
+end
+```
+
+Inside of immutabler you can describe enums, fields and mappings.
+
+## Models
+
+Model is describing in `model` block:
+
+```ruby
+model :ModelName do
+
+end
+```
+
+You can specify base class for model using `base` option:
+
+```ruby
+model :User, base: MyModel do
+
+end
+```
+
+## Enums
+
+Enum is describing in `enum` block:
+
+```ruby
+enum :EnumName do
+
+end
+```
+
+Generated enum will have group prefix.
+
+Generated enum members will have a group prefix and the enum name.
+
+For example: `GroupPrefixEnumNameMember1`
+
+Example:
+```ruby
+enum :EnumName do
+  attr :Member1
+  attr :Member2
+end
+```
+
+## Fields
+
+Fields are defing in `fields` block:
+
+```ruby
+fields do
+
+end
+```
+
+Each field is defining by
+
+```ruby
+    prop :fieldName, :fieldType
+```
+
+There are predefined types:
+* int
+* float
+* bool
+* string
+* array
+* dict
+* id
+
+When you use custom type and it will be transformed into the same.
+
+You can pass additional parameters for prop:
+
++ prefix: prefix used in Objective-C code (e.g. `*` for referential types).
++ ref: reference type in Objective-C code (e.g. `weak`)
+
+Example:
+```ruby
+  fields do
+    prop :modelId,     :int
+    prop :address,     :string
+    prop :phone,       :string
+    prop :walkIns,     :array
+    prop :workingDays, :dict
+    prop :state,       :TEState, prefix: '', ref: :weak
+end
+```
+
+## Mappings
+
+All mappings are describing in `mapping` block
+```ruby
+mapping do
+
+end
+```
+
+### Simple mapping
+
+Simple mappings are describing wih `map`:
+
+```ruby
+map :json_field_name, :classFieldName
+```
+
+You can specify custom transformer class using `with` option:
+
+```ruby
+map :phone, :phoneNumber, with: :CustomPhoneTransformer
+```
+
+### Array mapping
+
+You can describe mapping array of records using `array`:
+
+```ruby
+array :json_field_name, :classFieldName, :ClassName
+```
+
+### Dict mapping
+
+You can describe mapping json field to custom value (e.g. into enum) with `dict`:
+
+```ruby
+dict  :json_state, :modelState do
+  map :active,   :TEServiceStateActive
+  map :archived, :TEServiceStateArchived
+end
+```
+
+# Full example
+```ruby
+require 'immutabler'
+
+gen_path = './MasterApp/gen'
+
+Immutabler.group :TESalonModels do
+
+  output_dir(gen_path)
+  prefix('TE')
+  base_model('MTLModel<MTLJSONSerializing>') # Defaut base model for group
+
+  enum :ServiceState do
+    attr :Archived
+    attr :Active
+  end
+
+  model :Salon, base: 'CustomModel' do
+    fields do
+      prop :modelId,     :int
+      prop :address,     :string
+      prop :phone,       :string
+      prop :walkIns,     :array
+      prop :workingDays, :dict
+      prop :state,       :TEState, ref: :weak, prefix: '*'
+    end
+
+    mapping do
+      map   :id,       :modelId
+      map   :phone,    :phone, with: :CustomPhoneTransformer
+      array :walk_ins, :walkIns, :TEWalkIn
+      dict  :state,    :state do
+        map :active,   :TEServiceStateActive
+        map :archived, :TEServiceStateArchived
+      end
+    end
+  end
+```
+
+# How to run
+
+Run in command line from project root directory
+```shell
+ruby MasterApp/models.rb
+```
+
+Output files will be generated in the specified `output_dir`

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in immutabler.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,23 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Techery http://techery.io
+Serhij Korochanskyj <serge.k@techery.io>
+Sergey Zenchenko <serge.z@techery.io>
+
+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,40 @@
+Immutabler
+=========
+
+Generator of Objective-C immutable models
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'immutabler'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install immutabler
+
+## Getting started
+
+[Getting started is here](https://github.com/techery/immutabler/blob/master/GETTING_STARTED.md)
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/techery/immutabler. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'immutabler'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/immutabler.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'immutabler/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'immutabler'
+  spec.version       = Immutabler::VERSION
+  spec.authors       = ['Serhij Korochanskyj', 'Sergey Zenchenko']
+  spec.email         = ['serge.k@techery.io', 'serge.z@techery.io']
+
+  spec.summary       = 'Generator of Objective-C immutable models'
+  spec.description   = 'Generator of Objective-C immutable models'
+  spec.homepage      = 'https://github.com/techery/immutabler'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'handlebars', '~> 0.7'
+
+  spec.add_development_dependency 'bundler', '~> 1.10'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec'
+end

data/lib/immutabler/core.rb

@@ -0,0 +1,13 @@
+require_relative 'type_mapper'
+require_relative 'template/builder'
+require_relative 'dsl/group'
+
+module Immutabler
+  def self.group(group_name, &block)
+    group = DSL::Group.new(group_name)
+    group.instance_eval(&block)
+
+    builder = Template::Builder.new(group)
+    builder.build
+  end
+end

data/lib/immutabler/dsl/dict_mappings_builder.rb

@@ -0,0 +1,19 @@
+module Immutabler
+  module DSL
+    class DictMappingsBuilder
+      def initialize(dict_mappings, &block)
+        @dict_mappings = dict_mappings
+        instance_eval(&block)
+      end
+
+      def map(origin_name, destination_name)
+        dict_mapping =
+          {
+            origin_name: origin_name.to_s,
+            destination_name: destination_name.to_s
+          }
+        @dict_mappings << dict_mapping
+      end
+    end
+  end
+end

data/lib/immutabler/dsl/enum.rb

@@ -0,0 +1,12 @@
+module Immutabler
+  module DSL
+    class Enum
+      attr_accessor :name, :attributes
+
+      def initialize(name, attributes)
+        @name = name
+        @attributes = attributes
+      end
+    end
+  end
+end

data/lib/immutabler/dsl/enum_attribute.rb

@@ -0,0 +1,11 @@
+module Immutabler
+  module DSL
+    class EnumAttribute
+      attr_accessor :name
+
+      def initialize(name)
+        @name = name
+      end
+    end
+  end
+end

data/lib/immutabler/dsl/enum_attributes_builder.rb

@@ -0,0 +1,17 @@
+require_relative 'enum_attribute'
+
+module Immutabler
+  module DSL
+    class EnumAttributesBuilder
+      def initialize(attributes, prefix, &block)
+        @attributes = attributes
+        @prefix = prefix
+        instance_eval(&block)
+      end
+
+      def attr(name)
+        @attributes << EnumAttribute.new("#{@prefix}#{name}")
+      end
+    end
+  end
+end

data/lib/immutabler/dsl/group.rb

@@ -0,0 +1,65 @@
+require_relative 'enum'
+require_relative 'model'
+require_relative 'model_attributes_builder'
+require_relative 'enum_attributes_builder'
+
+module Immutabler
+  module DSL
+    class Group
+      attr_accessor :name, :models, :enums, :prefix, :links, :output_directory
+
+      def initialize(name)
+        @prefix = ''
+        @base_model = 'NSObject'
+        @name = name
+        @models = []
+        @enums = []
+        @links = []
+      end
+
+      def prefix(prefix)
+        self.prefix = prefix
+      end
+
+      def link_to(model_group_name)
+        links << model_group_name
+      end
+
+      def output_dir(dir)
+        self.output_directory = dir
+      end
+
+      def base_model(name)
+        @base_model = name
+      end
+
+      def enum(name, &block)
+        attributes = []
+        prefix = "#{@prefix}#{name}"
+        EnumAttributesBuilder.new(attributes, prefix, &block)
+        @enums << Enum.new(prefix, attributes)
+      end
+
+      def model(name, options = {}, &block)
+        prefix = @prefix + name.to_s
+        base = options.fetch(:base, @base_model).to_s
+        props = []
+        mappings = []
+        ModelAttributesBuilder.new(props, mappings, &block)
+
+        model = Model.new(prefix, base, props, mappings)
+
+        models << model
+      end
+
+      def build
+        {
+          name: name,
+          models: models,
+          links: links,
+          enums: enums
+        }
+      end
+    end
+  end
+end

data/lib/immutabler/dsl/mapping.rb

@@ -0,0 +1,29 @@
+module Immutabler
+  module DSL
+    class Mapping
+      attr_accessor :origin_name, :destination_name, :type, :dict_mappings, :custom_transformer
+
+      def initialize(origin_name, destination_name, options = {})
+        @origin_name = origin_name
+        @destination_name = destination_name
+        @type = options[:type]
+        @is_array = options.fetch(:array, false)
+        @is_dict  = options.fetch(:dict,  false)
+        @custom_transformer = options[:with]
+        @dict_mappings = []
+      end
+
+      def array?
+        @is_array
+      end
+
+      def dict?
+        @is_dict
+      end
+
+      def custom?
+        !custom_transformer.nil?
+      end
+    end
+  end
+end

data/lib/immutabler/dsl/mappings_builder.rb

@@ -0,0 +1,31 @@
+require_relative 'mapping'
+require_relative 'dict_mappings_builder'
+
+module Immutabler
+  module DSL
+    class MappingsBuilder
+      def initialize(mappings, &block)
+        @mappings = mappings
+        instance_eval(&block)
+      end
+
+      def map(origin_name, destination_name, options = {})
+        @mappings << Mapping.new(origin_name.to_s, destination_name.to_s, options)
+      end
+
+      def array(origin_name, destination_name, type)
+        options = {
+          type: type.to_s,
+          array: true
+        }
+        @mappings << Mapping.new(origin_name.to_s, destination_name.to_s, options)
+      end
+
+      def dict(origin_name, destination_name, &block)
+        mapping = Mapping.new(origin_name.to_s, destination_name.to_s, dict: true)
+        DictMappingsBuilder.new(mapping.dict_mappings, &block)
+        @mappings << mapping
+      end
+    end
+  end
+end

data/lib/immutabler/dsl/model.rb

@@ -0,0 +1,14 @@
+module Immutabler
+  module DSL
+    class Model
+      attr_accessor :name, :base, :props, :mappings
+
+      def initialize(name, base, props, mappings)
+        @name = name
+        @base = base
+        @props = props
+        @mappings = mappings
+      end
+    end
+  end
+end

data/lib/immutabler/dsl/model_attributes_builder.rb

@@ -0,0 +1,22 @@
+require_relative 'props_builder'
+require_relative 'mappings_builder'
+
+module Immutabler
+  module DSL
+    class ModelAttributesBuilder
+      def initialize(props, mappings, &block)
+        @props = props
+        @mappings = mappings
+        instance_eval(&block)
+      end
+
+      def fields(&block)
+        PropsBuilder.new(@props, &block)
+      end
+
+      def mapping(&block)
+        MappingsBuilder.new(@mappings, &block)
+      end
+    end
+  end
+end

data/lib/immutabler/dsl/prop.rb

@@ -0,0 +1,13 @@
+module Immutabler
+  module DSL
+    class Prop
+      attr_accessor :name, :type, :options
+
+      def initialize(name, type, options)
+        @name = name
+        @type = type
+        @options = options
+      end
+    end
+  end
+end

data/lib/immutabler/dsl/props_builder.rb

@@ -0,0 +1,20 @@
+require_relative 'prop'
+
+module Immutabler
+  module DSL
+    class PropsBuilder
+      def initialize(props, &block)
+        @props = props
+        instance_eval(&block)
+      end
+
+      def prop(name, type, options={})
+        prop_options = {}
+        prop_options[:is_ref] = !!options[:ref] if options.key?(:ref)
+        prop_options[:ref_type] = options[:ref] if options.key?(:ref)
+        prop_options[:name_prefix] = options[:prefix] if options.key?(:prefix)
+        @props << Prop.new(name.to_s, type.to_s, prop_options)
+      end
+    end
+  end
+end

data/lib/immutabler/template/body_template.rb

@@ -0,0 +1,44 @@
+require_relative 'template'
+
+module Immutabler
+  module Template
+    class BodyTemplate < BaseTemplate
+      attr_accessor :name, :models
+
+      def initialize(name, models)
+        self.template_file = File.expand_path("#{__dir__}/../../../templates/body_template.hbs")
+        self.name = name
+        self.models = models
+
+        helper(:dict) do |context, arg, block|
+          body = "@{\n"
+
+          if arg
+            body << arg.map{|m|
+              "@\"#{m.destination_name}\" : @\"#{m.origin_name}\""
+            }.join(",\n")
+          end
+
+          body << "\n};"
+        end
+
+        helper(:enum_mapping_dict) do |context, arg, block|
+          body = "@{\n"
+
+          if arg
+            body << arg.map{|m|
+              "@\"#{m.origin_name}\" : @(#{m.destination_name})"
+            }.join(",\n")
+          end
+
+          body << "\n};"
+        end
+
+      end
+
+      def render
+        template.call(models: models, name: name)
+      end
+    end
+  end
+end

data/lib/immutabler/template/builder.rb

@@ -0,0 +1,99 @@
+require 'fileutils'
+
+require_relative '../type_mapper'
+require_relative 'header_template'
+require_relative 'body_template'
+
+module Immutabler
+  module Template
+    class Builder
+      attr_accessor :group
+
+      def initialize(group)
+        @group = group
+      end
+
+      def build
+        defs = group.build
+
+        group_name = defs[:name]
+        models = defs[:models].map do |model|
+          {
+            name: model.name,
+            base_class: model.base,
+            props: build_props(model.props),
+            any_mappings: model.mappings.any?,
+            array_mappings: model.mappings.select(&:array?),
+            dict_mappings:  build_dict_mappings(model.mappings),
+            custom_mappers: build_custom_mappers(model.mappings),
+            mappings: build_mappings(model.mappings)
+          }
+        end
+
+        links = defs[:links]
+        enums = defs[:enums]
+
+        FileUtils.mkdir_p(group.output_directory)
+
+        build_head(group_name, models, links, enums)
+        build_body(group_name, models)
+      end
+
+      private
+
+      def build_props(props)
+        props.map do |prop|
+          Immutabler::TypeMapper.map(prop.type, prop.options).merge(name: prop.name)
+        end
+      end
+
+      def build_dict_mappings(mappings)
+        mappings.select(&:dict?).map do |mapping|
+          attributes = mapping.dict_mappings.map do |dict_mapping|
+            {
+              origin_name:      dict_mapping[:origin_name],
+              destination_name: dict_mapping[:destination_name]
+            }
+          end
+
+          {
+            name: mapping.destination_name,
+            attributes: attributes
+          }
+        end
+      end
+
+      def build_mappings(mappings)
+        mappings.map do |mapping|
+          {
+            origin_name: mapping.origin_name,
+            destination_name: mapping.destination_name
+          }
+        end
+      end
+
+      def build_custom_mappers(mappings)
+        mappings.select(&:custom?).map do |mapping|
+          {
+            origin_name: mapping.origin_name,
+            transformer_name: mapping.custom_transformer
+          }
+        end
+      end
+
+      def build_body(group_name, models)
+        body_template = Immutabler::Template::BodyTemplate.new(group_name, models)
+        body_content = body_template.render
+        body_path = "#{group.output_directory}/#{group_name}.m"
+        File.write(body_path, body_content)
+      end
+
+      def build_head(group_name, models, links, enums)
+        header_template = Immutabler::Template::HeaderTemplate.new(models, links, enums)
+        header_content = header_template.render
+        header_path = "#{group.output_directory}/#{group_name}.h"
+        File.write(header_path, header_content)
+      end
+    end
+  end
+end

data/lib/immutabler/template/header_template.rb

@@ -0,0 +1,60 @@
+require_relative 'template'
+
+module Immutabler
+  module Template
+    class HeaderTemplate < BaseTemplate
+      attr_accessor :models, :links, :enums
+
+      def initialize(models, links, enums)
+        self.template_file = File.expand_path("#{__dir__}/../../../templates/header_template.hbs")
+        self.links = links
+        self.models = models
+        self.enums = build_enums(enums)
+
+        helper(:interface) do |context, arg, block|
+          [
+            "@interface #{arg[:name]} : #{arg[:base_class]}",
+            '',
+            "#{block.fn(context)}",
+            '@end',
+            ''
+          ].join("\n")
+        end
+
+        helper(:declare_props) do |context, arg, block|
+          arg.map do |prop|
+            options = block[:hash]
+            access_type = options[:readOnly] ? 'readonly' : 'readwrite'
+            prop_arguments = "@property(nonatomic, #{prop[:ref_type]}, #{access_type})"
+            prop_field = "#{prop[:type]} #{prop[:name_prefix]}#{prop[:name]}"
+
+            "#{prop_arguments} #{prop_field};"
+          end.join("\n")
+        end
+
+        helper(:enum) do |context, arg, block|
+          [
+            'typedef enum {',
+            arg[:attributes].map(&:name).join(",\n"),
+            "} #{arg[:name]};",
+          ].join("\n")
+        end
+      end
+
+      def build_enums(enums)
+        enums.map do |enum|
+          attributes = enum.attributes.map { |attr| { name: attr.name } }
+
+          {
+            name: enum.name,
+            attributes: attributes
+          }
+        end
+      end
+
+      def render
+        template.call(models: models, links: links, enums: enums)
+      end
+    end
+  end
+end

data/lib/immutabler/template/template.rb

@@ -0,0 +1,33 @@
+require 'handlebars'
+
+class String
+  def unindent
+    gsub(/^#{match(/^\s+/)}/, '')
+  end
+end
+
+module Immutabler
+  module Template
+    class BaseTemplate
+      attr_accessor :template_file
+
+      def raw_template
+        @raw_template ||= File.read(template_file)
+      end
+
+      def handlebars
+        @handlebars ||= Handlebars::Context.new
+      end
+
+      def template
+        @template ||= handlebars.compile(raw_template, {noEscape: true})
+      end
+
+      def helper(name, &helper_body)
+        handlebars.register_helper(name) do |context, arg, block|
+          helper_body.call(context, arg, block).unindent
+        end
+      end
+    end
+  end
+end

data/lib/immutabler/type_mapper.rb

@@ -0,0 +1,63 @@
+module Immutabler
+  class TypeMapper
+    TYPE_MAPPING = {
+      'int' => {
+        type: 'NSInteger',
+        is_ref: false,
+        ref_type: 'assign',
+        name_prefix: ''
+      },
+      'float' => {
+        type: 'CGFloat',
+        is_ref: false,
+        ref_type: 'assign',
+        name_prefix: ''
+      },
+      'bool' => {
+        type: 'BOOL',
+        is_ref: false,
+        ref_type: 'assign',
+        name_prefix: ''
+      },
+      'array' => {
+        type: 'NSArray',
+        is_ref: true,
+        ref_type: 'strong',
+        name_prefix: '*'
+      },
+      'string' => {
+        type: 'NSString',
+        is_ref: true,
+        ref_type: 'strong',
+        name_prefix: '*'
+      },
+      'dict' => {
+        type: 'NSDictionary',
+        is_ref: true,
+        ref_type: 'strong',
+        name_prefix: '*',
+      },
+      'id' => {
+        type: 'id',
+        is_ref: true,
+        ref_type: 'strong',
+        name_prefix: ''
+      }
+    }
+
+    def self.map(type, options)
+      TYPE_MAPPING.fetch(type, default_mapping(type)).merge(options)
+    end
+
+    private
+
+    def self.default_mapping(type)
+      {
+        type: type,
+        is_ref: true,
+        ref_type: 'strong',
+        name_prefix: '*'
+      }
+    end
+  end
+end

data/lib/immutabler/version.rb

@@ -0,0 +1,3 @@
+module Immutabler
+  VERSION = '0.1.0'
+end

data/lib/immutabler.rb

@@ -0,0 +1,2 @@
+require 'immutabler/version'
+require 'immutabler/core'

data/templates/body_template.hbs

@@ -0,0 +1,187 @@
+#import "{{name}}.h"
+
+{{#models}}
+@class {{name}};
+{{/models}}
+
+{{#models}}
+
+@implementation {{name}} {
+    int __modelVersion;
+}
+
+{{#any_mappings}}
++ (NSDictionary *)JSONKeyPathsByPropertyKey {
+    return {{#dict mappings}}{{/dict}}
+}
+{{/any_mappings}}
+
+{{#custom_mappers}}
++ (NSValueTransformer *){{origin_name}}JSONTransformer {
+    return [ [{{transformer_name}} alloc] init];
+}
+{{/custom_mappers}}
+
+{{#array_mappings}}
++ (NSValueTransformer *){{destination_name}}JSONTransformer {
+    return [MTLJSONAdapter arrayTransformerWithModelClass:[{{type}} class]];
+}
+{{/array_mappings}}
+
+{{#dict_mappings}}
++ (NSValueTransformer *){{name}}JSONTransformer {
+    NSDictionary *dict = {{#enum_mapping_dict attributes}}{{/enum_mapping_dict}}
+    return [MTLValueTransformer transformerUsingForwardBlock:^NSNumber *(NSString *string, BOOL *success, NSError *__autoreleasing *error) {
+       return dict[string];
+   } reverseBlock:^NSString *(NSNumber *number, BOOL *success, NSError *__autoreleasing *error) {
+       return [dict allKeysForObject:number].firstObject;
+   }];
+}
+{{/dict_mappings}}
+
++ ({{name}}*)create:(void(^)({{name}}Builder *builder))builderBlock
+{
+    {{name}}Builder *builder = [{{name}}Builder new];
+    if(builderBlock)
+    {
+        builderBlock(builder);
+    }
+    return [[self alloc] initWithBuilder:builder modelVersion:1];
+}
+
+- (instancetype)init
+{
+    {{name}}Builder *builder = [{{name}}Builder new];
+    return [[[self class] alloc] initWithBuilder:builder modelVersion:1];
+}
+
+- (instancetype)initWithBuilder:({{name}}Builder*)builder modelVersion:(int)modelVersion
+{
+    self = [super init];
+
+    if (self) {
+        __modelVersion = modelVersion;
+        {{#props}}
+        _{{name}} = builder.{{name}};
+        {{/props}}
+    }
+
+    return self;
+}
+
+- ({{name}}*)mutate:(void(^)({{name}}Builder *builder))builderBlock
+{
+    {{name}}Builder *builder = [{{name}}Builder new];
+
+    {{#props}}
+    builder.{{name}} = self.{{name}};
+    {{/props}}
+
+    builderBlock(builder);
+
+    return [[[self class] alloc] initWithBuilder:builder modelVersion:__modelVersion + 1];
+}
+
+- (BOOL)isEqual:(id)other {
+    if (other == self)
+        return YES;
+    if (!other || ![[other class] isEqual:[self class]])
+        return NO;
+
+    return [self isEqualToOther:other];
+}
+
+- (BOOL)isEqualToOther:({{name}} *)object {
+    if (self == object)
+        return YES;
+    if (object == nil)
+        return NO;
+    {{#props}}
+    if (self.{{name}} != object.{{name}})
+        return NO;
+    {{/props}}
+    return YES;
+}
+
+- (NSUInteger)hash {
+    NSUInteger hash = 0;
+    {{#props}}
+    {{#is_ref}}
+    hash = hash * 31u + [self.{{name}} hash];
+    {{/is_ref}}
+    {{^is_ref}}
+    hash = hash * 31u + self.{{name}};
+    {{/is_ref}}
+    {{/props}}
+    return hash;
+}
+
+- (NSString *)description {
+    NSMutableString *description = [NSMutableString stringWithFormat:@"<%@: ", NSStringFromClass([self class])];
+    [description appendFormat:@"__modelVersion=%d", __modelVersion];
+    {{#props}}
+    {{#is_ref}}
+    [description appendFormat:@", {{name}}=%@", self.{{name}}];
+    {{/is_ref}}
+    {{^is_ref}}
+    [description appendFormat:@", {{name}}=%@", @(self.{{name}})];
+    {{/is_ref}}
+    {{/props}}
+    [description appendString:@">"];
+    return description;
+}
+
+- (id)initWithCoder:(NSCoder *)coder {
+    self = [super init];
+    if (self) {
+        {{#props}}
+        {{#is_ref}}
+        _{{name}} = [coder decodeObjectForKey:@"_{{name}}"];
+        {{/is_ref}}
+        {{^is_ref}}
+        _{{name}} = [coder decodeIntForKey:@"_{{name}}"];
+        {{/is_ref}}
+        {{/props}}
+        __modelVersion = [coder decodeIntForKey:@"__modelVersion"];
+    }
+
+    return self;
+}
+
+- (void)encodeWithCoder:(NSCoder *)coder {
+    {{#props}}
+    {{#is_ref}}
+    [coder encodeObject:self.{{name}} forKey:@"_{{name}}"];
+    {{/is_ref}}
+    {{^is_ref}}
+    [coder encodeInteger:self.{{name}} forKey:@"_{{name}}"];
+    {{/is_ref}}
+    {{/props}}
+    [coder encodeInt:__modelVersion forKey:@"__modelVersion"];
+}
+
+- (id)copyWithZone:(NSZone *)zone {
+    {{name}} *copy = [[[self class] allocWithZone:zone] init];
+
+    if (copy != nil) {
+        copy->__modelVersion = __modelVersion + 1;
+        {{#props}}
+        copy->_{{name}} = _{{name}};
+        {{/props}}
+    }
+
+    return copy;
+}
+
+
+@end
+
+@implementation {{name}}Builder
+
++ (NSDictionary *)JSONKeyPathsByPropertyKey {
+    return @{};
+}
+
+@end
+
+{{/models}}

data/templates/header_template.hbs

@@ -0,0 +1,37 @@
+#import <Foundation/Foundation.h>
+#import <Mantle/Mantle.h>
+
+{{#links}}
+#import "{{.}}.h"
+{{/links}}
+
+{{#enums}}
+{{#enum .}}
+{{/enum}}
+{{/enums}}
+
+{{#models}}
+
+@class {{name}}Builder;
+
+{{#interface .}}
+
+{{#declare_props props readOnly=true}}
+{{/declare_props}}
+
+
++ ({{name}}*)create:(void(^)({{name}}Builder *builder))builder;
+- ({{name}}*)mutate:(void(^)({{name}}Builder *builder))builder;
+
+
+{{/interface}}
+
+@interface {{name}}Builder : {{base_class}}
+
+{{#declare_props props readOnly=false}}
+{{/declare_props}}
+
+
+@end
+
+{{/models}}

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: immutabler
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Serhij Korochanskyj
+- Sergey Zenchenko
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-09-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: handlebars
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Generator of Objective-C immutable models
+email:
+- serge.k@techery.io
+- serge.z@techery.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- GETTING_STARTED.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- immutabler.gemspec
+- lib/immutabler.rb
+- lib/immutabler/core.rb
+- lib/immutabler/dsl/dict_mappings_builder.rb
+- lib/immutabler/dsl/enum.rb
+- lib/immutabler/dsl/enum_attribute.rb
+- lib/immutabler/dsl/enum_attributes_builder.rb
+- lib/immutabler/dsl/group.rb
+- lib/immutabler/dsl/mapping.rb
+- lib/immutabler/dsl/mappings_builder.rb
+- lib/immutabler/dsl/model.rb
+- lib/immutabler/dsl/model_attributes_builder.rb
+- lib/immutabler/dsl/prop.rb
+- lib/immutabler/dsl/props_builder.rb
+- lib/immutabler/template/body_template.rb
+- lib/immutabler/template/builder.rb
+- lib/immutabler/template/header_template.rb
+- lib/immutabler/template/template.rb
+- lib/immutabler/type_mapper.rb
+- lib/immutabler/version.rb
+- templates/body_template.hbs
+- templates/header_template.hbs
+homepage: https://github.com/techery/immutabler
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Generator of Objective-C immutable models
+test_files: []