mt_tool 0.1.2 → 0.1.5

data/lib/mt_tool/oc_model/oc_model.rb

@@ -0,0 +1,235 @@
+require 'json'
+require 'thor'
+require 'active_support/all'
+
+module MtTool
+
+  class OcModel < Thor
+
+    # constants
+    OBJC_TYPE_STRING = "NSString *"
+    OBJC_TYPE_NUMBER = "NSNumber *"
+    OBJC_TYPE_ID = "id"
+    OBJC_TYPE_NSDIC = "NSDictionary *"
+
+    OBJC_TYPE_ARRAY = "NSArray *"
+    OBJC_TYPE_BOOL = "BOOL"
+    OBJC_TYPE_NULL = "NSNull *"
+
+    # attributes
+    ATTRIBUTE_NONATOMIC = "nonatomic"
+    ATTRIBUTE_COPY = "copy"
+    ATTRIBUTE_STRONG= "strong"
+    ATTRIBUTE_ASSIGN= "assign"
+
+    $type_map = {
+      "String" => OBJC_TYPE_STRING,
+      "Integer" => OBJC_TYPE_NUMBER,
+      "Float" => OBJC_TYPE_NUMBER,
+      # "Hash" => OBJC_TYPE_ID,
+      "Hash" => OBJC_TYPE_NSDIC,
+      "Array" => OBJC_TYPE_ARRAY,
+      "TrueClass" => OBJC_TYPE_BOOL,
+      "FalseClass" => OBJC_TYPE_BOOL,
+      "NilClass" => OBJC_TYPE_NULL,
+    }
+
+    $attr_map = {
+      OBJC_TYPE_STRING => [ATTRIBUTE_NONATOMIC, ATTRIBUTE_COPY],
+      OBJC_TYPE_NUMBER => [ATTRIBUTE_NONATOMIC,ATTRIBUTE_COPY],
+      OBJC_TYPE_ID => [ATTRIBUTE_NONATOMIC,ATTRIBUTE_COPY],
+      OBJC_TYPE_NSDIC => [ATTRIBUTE_NONATOMIC,ATTRIBUTE_COPY],
+      OBJC_TYPE_ARRAY => [ATTRIBUTE_NONATOMIC, ATTRIBUTE_COPY],
+      OBJC_TYPE_BOOL => [ATTRIBUTE_NONATOMIC,ATTRIBUTE_ASSIGN],
+      OBJC_TYPE_NULL => [ATTRIBUTE_NONATOMIC,ATTRIBUTE_ASSIGN]
+    }
+
+    # generate info
+    $prop_declare = "@property"
+
+    include Thor::Actions
+
+    def initialize(args = [], options = {}, config = {})
+      super
+
+    end
+
+    no_commands do
+
+      def qt_create(prefix,name, path = nil ,output_path = nil)
+
+        @json_path = path
+        @class_full_name = name
+        @file_name = name+'Model'
+        @output_path = output_path
+        system "quicktype --src #{path} --src-lang json --class-prefix #{prefix}  --lang objc --top-level #{name} -o #{output_path}/#{prefix+name}   --just-types "
+      end
+
+      def create(prefix,name, path = nil ,output_path = nil)
+
+        @json_path = path
+        @prefix = prefix
+        @class_full_name = name
+        @file_name = prefix+name+'Model'
+        @output_path = output_path
+        operate
+      end
+
+      def operate
+
+        input_file = File.read(@json_path)
+        input_json = JSON.parse(input_file)
+
+
+        header_result = ""
+        result = add_header_with_kv input_json
+        header_result <<  result
+
+
+        imp_result = add_imp_with_kv input_json
+
+
+        header_file_name = "#{@file_name}.h"
+        header_file_path = "#{@output_path}/#{header_file_name}"
+        imp_file_name = "#{@file_name}.m"
+        imp_file_path = "#{@output_path}/#{imp_file_name}"
+
+        File.open(header_file_path, 'w') do |io|
+          io << header_result
+        end
+
+        File.open(imp_file_path, 'w') do |io|
+          io << imp_result
+        end
+
+      end
+
+
+
+      def add_header_with_kv(json)
+
+        header_comment = <<comment
+// #{@class_full_name}.h
+// 
+// Created by #{ENV['USER']} on #{Time.now.strftime("%Y/%m/%d")}
+comment
+
+        header_result = ''
+        header_result << header_comment
+        header_result << "\n\n\n"
+        header_result << "#import <Foundation/Foundation.h>\n\n"
+        header_result << "@interface #{@file_name} : NSObject\n\n"
+
+        sub_model_types = []
+        sub_model_kvs = {}
+
+        json.each do |key, value|
+          if value.class == Hash
+            attribute = attr_name_for_attr_array [ATTRIBUTE_NONATOMIC,ATTRIBUTE_STRONG]
+            type = @prefix+@class_full_name + key.camelize(:upper) + "Model"
+            var_name = key
+            header_result << "#{$prop_declare} (#{attribute}) #{type +" *"}#{var_name};\n"
+            sub_model_types.push type
+            sub_model_kvs[type] = value
+          elsif value.class == Array
+
+            attribute = attr_name_for_attr_array [ATTRIBUTE_NONATOMIC,ATTRIBUTE_STRONG]
+            type = @prefix+@class_full_name + key.camelize(:upper) + "Model"
+            var_name = key
+            header_result << "#{$prop_declare} (#{attribute}) NSArray <#{type+" *"}>*#{var_name};\n"
+            sub_model_types.push type
+            sub_model_kvs[type] = value
+          else
+            header_result << "#{prop_for_key_value(key, value)}\n"
+
+          end
+
+        end
+
+        header_result << "\n@end"
+
+
+        sub_model_types.each do |type|
+          header_result << "\n\n@interface #{type} : NSObject\n\n"
+
+          header_result << "\n@end\n"
+        end
+        header_result
+      end
+
+
+
+
+
+      def add_imp_with_kv(json)
+        imp_comment = <<comment
+// #{@class_full_name}.h
+// 
+// Created by #{ENV['USER']} on #{Time.now.strftime("%Y/%m/%d")}
+comment
+
+        imp_result = ""
+        imp_result << imp_comment
+        imp_result << "\n\n\n"
+        imp_result << "#import \"#{@prefix+@class_full_name}\"\n\n"
+        imp_result << "@interface #{@prefix+@class_full_name} ()\n\n\n@end\n\n"
+
+        imp_result << "@implementation #{@prefix+@class_full_name}\n"
+        imp_result << "\n\n@end"
+        imp_result << "\n\n------------\n"
+        sub_model_types = []
+
+
+        json.each do |key, value|
+          if value.class == Hash
+            type = @prefix+@class_full_name + key.camelize(:upper) + "Model"
+            sub_model_types.push type
+          elsif value.class == Array
+            type = @prefix+@class_full_name + key.camelize(:upper) + "Model"
+            sub_model_types.push type
+          else
+
+          end
+
+        end
+        sub_model_types.each do |type|
+          imp_result << "\n\n@implementation #{type} "
+
+          imp_result << "\n@end\n"
+        end
+        imp_result
+
+      end
+
+      def attr_name_for_attr_array(attr_array)
+        attr_name = ""
+
+        attr_array.each_with_index do |attribute, index|
+          if index != 0
+            attr_name << ", #{attribute}"
+          else
+            attr_name << "#{attribute}"
+          end
+
+        end
+
+        return attr_name
+      end
+
+      def prop_for_key_value(key, value)
+        type = $type_map["#{value.class}"]
+        attribute = attr_name_for_attr_array($attr_map[type])
+        var_name = key.camelize(:lower)
+        if key =='id'
+          var_name = 'ID'
+        end
+        prop_ret = "#{$prop_declare} (#{attribute}) #{type}#{var_name};"
+
+        return prop_ret
+      end
+
+
+
+    end
+  end
+end

data/lib/mt_tool/oc_model/sample.json

@@ -0,0 +1,11 @@
+{
+  "someString": "string",
+  "someInt": 42,
+  "someMinusInt": -42,
+  "someFloat": -4.2,
+  "someObject": {},
+  "someArray": [],
+  "someTrue": true,
+  "someFalse": false,
+  "someNull": null
+}

data/lib/mt_tool/short_hand/objc_generate_from_shorthand.rb

@@ -0,0 +1,182 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'mustache'
+require 'objc_shorthand'
+
+# -------------
+
+class ObjCClassTemplate < Mustache	
+	attr_accessor :cls, :shorthand_file
+	
+	def initialize cls, shorthand_file
+		@cls = cls
+		@shorthand_file = shorthand_file
+	end
+	
+	def ivars
+		@cls.objc_ivars.map { |name, x| ObjCIvarTemplate.new(x) }
+	end
+	
+	def ivars_with_properties; ivars; end
+	def ivars_without_properties; []; end
+	
+	def ivars_with_properties_without_ro
+		ivars_with_properties.select { |x| not x.ivar.options.include? :ro }
+	end
+	
+	def ivars_without_properties_or_with_ro
+		ivars_with_properties.select { |x| x.ivar.options.include? :ro }
+	end
+	
+	def frameworks
+		@cls.objc_frameworks
+	end
+	
+	def imports
+		@cls.objc_imports
+	end
+	
+	def class_name
+		@cls.objc_name
+	end
+	
+	def superclass_name
+		@cls.objc_superclass_name
+	end
+	
+	def needs_legacy
+		true
+	end
+end
+
+class ObjCIvarTemplate
+	def initialize ivar
+		@ivar = ivar
+	end
+	
+	attr_reader :ivar
+	
+	def ivar_type
+		t = ivar.objc_type
+		t = "NSString*" if t == :str
+		t = "NSInteger" if t == :int
+		t = "NSUInteger" if t == :uint
+		t = "BOOL" if t == :bool
+		t = "#{t}*" if t.kind_of? Symbol and t != :id and t != :Class
+		t
+	end
+	
+	def is_object_type
+		t = ivar.objc_type
+		return true if ivar.options.include?(:object)
+		return false if (t == :int or t == :uint or t == :bool)
+		return true if t.kind_of?(Symbol)
+		
+		(t =~ /^\s*id\s*(<|$)/) != nil
+	end
+	
+	def ivar_name
+		"#{ivar.name}_"
+	end
+	
+	def outlet_marker
+		'IBOutlet' if ivar.options.include? :outlet
+	end
+	
+	def memory_management_marker
+		if is_object_type
+			if ivar.options.include? :retain
+				'retain'
+			elsif ivar.options.include? :copy
+				'copy'
+			elsif ivar.options.include? :assign
+				'assign'
+			elsif ivar.name.to_s == 'delegate' or ivar.name.to_s =~ /Delegate$/ and not ivar.options.include? :ro
+				'assign'
+			elsif not ivar.options.include? :ro
+				'retain'
+			end
+		end
+	end
+	
+	def property_modifiers
+		s = []
+		
+		marker = memory_management_marker
+		s << marker if marker
+		
+		s << 'nonatomic' unless ivar.options.include? :atomic
+		
+		if ivar.options.include? :ro
+			s << 'readonly'
+		end
+		
+		getter_name = ivar.options.select { |x| x.kind_of? ObjCIvarGetterNameOption }[0]
+		if getter_name
+			s << "getter = #{getter_name.name}"
+		end
+		
+		return "(#{s.join ','})"
+	end
+	
+	def property_name
+		ivar.name
+	end
+	
+	def capitalized_property_name
+		p = property_name.to_s.dup
+		p[0,1] = p[0,1].upcase
+		p
+	end
+	
+	def will_set
+		ivar.options.include? :will_set
+	end
+	
+	def did_set
+		ivar.options.include? :did_set
+	end
+	
+	def will_get
+		ivar.options.include? :will_get
+	end
+	
+	def needs_explicit_setter
+		will_set || did_set
+	end
+	
+	def needs_explicit_getter
+		will_get
+	end
+	
+	def is_assign
+		marker = memory_management_marker
+		marker != 'retain' and marker != 'copy'
+	end
+	
+	def memory_management_call
+		memory_management_marker
+	end
+	
+end
+
+# -------------
+
+load ARGV[0]
+
+OBJC_CLASSES.each do |name, cls|
+	File.open("#{name}.h", 'w') do |io|
+		t = ObjCClassTemplate.new(cls, File.expand_path(ARGV[0]))
+		t.template_file = File.join(File.dirname(__FILE__), 'objc_header.mustache')
+		
+		io << t.render
+	end
+	
+	File.open("#{name}.m", 'w') do |io|
+		t = ObjCClassTemplate.new(cls, File.expand_path(ARGV[0]))
+		t.template_file = File.join(File.dirname(__FILE__), 'objc_implementation.mustache')
+		
+		io << t.render
+	end
+end

data/lib/mt_tool/short_hand/objc_header.mustache

@@ -0,0 +1,41 @@
+
+// ----------------------------
+// AUTOGENERATED FROM:
+// {{{shorthand_file}}}
+// ----------------------------
+
+{{#frameworks}}
+#import <{{{.}}}/{{{.}}}.h>
+{{/frameworks}}
+{{^frameworks}}
+#import <Foundation/Foundation.h>
+{{/frameworks}}
+
+{{#imports}}
+#import "{{{.}}}"
+{{/imports}}
+
+@interface {{{class_name}}} : {{{superclass_name}}}
+{{#needs_legacy}}
+{
+@protected
+{{#ivars}}
+	{{{ivar_type}}} {{{ivar_name}}};
+{{/ivars}}
+}
+{{/needs_legacy}}
+
+{{#ivars_with_properties}}
+@property{{{property_modifiers}}} {{{outlet_marker}}} {{{ivar_type}}} {{{property_name}}};
+{{#will_get}}
+- (void) willReturnValueFor{{{capitalized_property_name}}};
+{{/will_get}}
+{{#will_set}}
+- ({{{ivar_type}}}) {{{property_name}}}WillChangeToValue:({{{ivar_type}}}) aNewValue fromValue:({{{ivar_type}}}) anOldValue;
+{{/will_set}}
+{{#did_set}}
+- (void) {{{property_name}}}DidChangeToValue:({{{ivar_type}}}) aNewValue fromValue:({{{ivar_type}}}) anOldValue;
+{{/did_set}}
+{{/ivars_with_properties}}
+
+@end

data/lib/mt_tool/short_hand/objc_implementation.mustache

@@ -0,0 +1,99 @@
+
+// ----------------------------
+// AUTOGENERATED FROM:
+// {{{shorthand_file}}}
+// ----------------------------
+
+#import "{{{class_name}}}.h"
+
+@implementation {{{class_name}}}
+
+{{#ivars_with_properties}}
+@synthesize {{{property_name}}} = {{{ivar_name}}};
+{{/ivars_with_properties}}
+
+- (void) dealloc;
+{
+	{{#ivars_with_properties_without_ro}}
+	{{^is_assign}}
+	self.{{{property_name}}} = nil;
+	{{/is_assign}}
+	{{/ivars_with_properties_without_ro}}
+	
+	{{#ivars_without_properties_or_with_ro}}
+	{{^is_assign}}
+	[{{{ivar_name}}} release];
+	{{/is_assign}}
+	{{#is_assign}}
+	// {{{ivar_name}}} is assigned
+	{{/is_assign}}
+	{{/ivars_without_properties_or_with_ro}}
+	
+	[super dealloc];
+}
+
+{{#ivars_with_properties}}
+	{{#needs_explicit_getter}}
+- ({{{ivar_type}}}) {{{property_name}}};
+{
+	{{#will_get}}
+	[self willReturnValueFor{{{capitalized_property_name}}}];
+	{{/will_get}}
+	
+	return {{{ivar_name}}};
+}
+	{{#will_get}}
+- (void) willReturnValueFor{{{capitalized_property_name}}};
+{}
+	{{/will_get}}
+
+	{{/needs_explicit_getter}}
+
+	{{#needs_explicit_setter}}
+- (void) set{{{capitalized_property_name}}}:({{{ivar_type}}}) aNewValue;
+{
+	if (aNewValue != {{{ivar_name}}}) {
+		
+	{{#will_set}}
+		aNewValue = [self {{{property_name}}}WillChangeToValue:aNewValue fromValue:{{{ivar_name}}}];
+		if (aNewValue == {{{ivar_name}}})
+			return;
+	{{/will_set}}
+	{{#did_set}}
+		{{{ivar_type}}} anOldValue = {{{ivar_name}}};
+	{{/did_set}}
+	{{^is_assign}}
+		{{#did_set}}
+			[[anOldValue retain] autorelease];
+		{{/did_set}}
+	{{/is_assign}}
+
+	{{#is_assign}}
+		{{{ivar_name}}} = aNewValue;
+	{{/is_assign}}
+	{{^is_assign}}
+		[{{{ivar_name}}} release];
+		{{{ivar_name}}} = [aNewValue {{{memory_management_call}}}];
+	{{/is_assign}}
+	
+	{{#did_set}}
+		[self {{{property_name}}}DidChangeToValue:aNewValue fromValue:anOldValue];
+	{{/did_set}}
+	
+	}
+}
+
+{{#will_set}}
+- ({{{ivar_type}}}) {{{property_name}}}WillChangeToValue:({{{ivar_type}}}) aNewValue fromValue:({{{ivar_type}}}) anOldValue;
+{
+	return aNewValue;
+}
+{{/will_set}}
+{{#did_set}}
+- (void) {{{property_name}}}DidChangeToValue:({{{ivar_type}}}) aNewValue fromValue:({{{ivar_type}}}) anOldValue;
+{}
+{{/did_set}}
+	{{/needs_explicit_setter}}
+{{/ivars_with_properties}}
+
+@end

data/lib/mt_tool/short_hand/objc_shorthand.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+
+class ObjCClass
+	def initialize name
+		@objc_name = name
+		@objc_superclass_name = :NSObject
+		@objc_ivars = {}
+		@objc_frameworks = []
+		@objc_imports = []
+	end
+	
+	def subclass_of x
+		@objc_superclass_name = x
+	end
+	
+	def ivar name, type = nil, *options
+		@objc_ivars[name] = ObjCIvar.new name, type || :id, options
+	end
+	
+	def framework x
+		@objc_frameworks << x unless @objc_frameworks.include? x
+	end
+
+	def import x
+		@objc_imports << x unless @objc_imports.include? x
+	end
+	
+	def method_missing name, type = nil, *options
+		ivar name, type, *options
+	end
+	
+	def getter(name)
+		return ObjCIvarGetterNameOption.new(name)
+	end
+	
+	attr_reader :objc_name, :objc_ivars, :objc_frameworks, :objc_imports, :objc_superclass_name
+end
+
+class ObjCIvarGetterNameOption
+	def initialize name
+		@name = name
+	end
+	
+	attr_reader :name
+end
+
+class ObjCIvar
+	def initialize name, type, options
+		@name = name
+		@objc_type = type
+		@options = options
+	end
+	
+	attr_reader :name, :objc_type, :options
+end
+
+OBJC_CLASSES = {} unless 
+
+def objc_class name, &block
+	x = ObjCClass.new(name)
+	OBJC_CLASSES[name] = x
+	x.instance_eval(&block)
+	x
+end

data/lib/mt_tool/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MtTool
-  VERSION = "0.1.2"
+  VERSION = "0.1.5"
 end

data/mt_tool.gemspec

@@ -42,8 +42,10 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'thor'
   spec.add_dependency 'xcodeproj'
   spec.add_dependency 'colored'
+  spec.add_dependency 'colored2'
   spec.add_dependency 'pathname'
-
+  spec.add_dependency 'mustache'
+  spec.add_dependency 'activesupport'
   # For more information and examples about making a new gem, check out our
   # guide at: https://bundler.io/guides/creating_gem.html
 end