nidyx 0.1.0

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Chris Knadler
+
+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,146 @@
+# Nidyx ![Build Status](https://travis-ci.org/cknadler/nidyx.svg?branch=master)
+
+[JSON Schema][JSONSchema] ⇒ Model.
+
+Nidyx generates Objective-C models from JSON Schema. It can also generate
+models with [JSONModel](https://github.com/icanzilb/JSONModel) support.
+
+## Usage
+
+```
+usage: nidyx [-h] [--version]
+       nidyx <schema> <class-prefix> [output-directory]
+             [-j] [-n] [-a author] [-c company] [-p project]
+
+    -a, --author AUTHOR              Author's name
+    -c, --company COMPANY            Company's name
+    -p, --project PROJECT            Project's name
+    -j, --json-model                 Generate with JSONModel support
+    -n, --no-comments                Generate without header comments
+    -h, --help                       Print usage information
+        --version                    Print version
+
+Nidyx generates plain Objective-C models from JSON Schema. It can also generate
+models with JSONModel support.
+
+Examples
+========
+
+Bare minimum. Given a schema and a class prefix, generate models in the
+current directory:
+
+  $ nidyx example.json.schema ClassPrefix
+
+Specify an ouput directory:
+
+  $ nidyx example.json.schema ClassPrefix /path/to/output/directory
+
+Generate models with JSONModel support and all optional documentation:
+
+  $ nidyx example.json.schema ClassPrefix /path/to/output/directory \
+    -j -a "Your Name" -c "Company Name" -p "Project Name"
+
+```
+
+## Features
+
+__[JSON Schema draft 4][JSONSchemaDraft4] support:__
+
+Nidyx exclusively supports JSON Schema draft 4. All previous drafts are not
+supported intentionally.
+
+## Examples
+
+Examples are run with the following unless otherwise specified:
+
+```bash
+$ nidyx example.json.schema Example
+```
+
+#### Simple Properties
+
+```json
+{
+  "properties": {
+    "key": { "type": "string" },
+    "value": { "type": "string" }
+  }
+}
+```
+
+```objc
+// ExampleModel.h
+@interface ExampleModel
+@property (strong, nonatomic) NSString* key;
+@property (strong, nonatomic) NSString* value;
+@end
+```
+
+#### Refs and Nested Properties
+
+```json
+{
+  "properties": {
+    "id": {
+      "type": "object",
+      "properties": {
+        "key": { "type": "string" },
+        "hash": { "type": "string" }
+      }
+    },
+    "value":  { "$ref": "#/definitions/obj" }
+  },
+  "definitions": {
+    "obj": {
+      "type": "object",
+      "properties": {
+        "banner": { "$ref": "#/definitions/banner" },
+        "name": { "type": "string" },
+        "count": { "type": "integer" }
+      }
+    },
+    "banner": { "type": "string" }
+  }
+}
+```
+
+```objc
+// ExampleModel.h
+#import "ExampleIdModel.h"
+#import "ExampleObjModel.h"
+@interface ExampleModel
+@property (strong, nonatomic) ExampleIdModel* id;
+@property (strong, nonatomic) ExampleObjModel* value;
+@end
+
+// ExampleIdModel.h
+@interface ExampleIdModel
+@property (strong, nonatomic) NSString* key;
+@property (strong, nonatomic) NSString* hash;
+@end
+
+// ExampleObjModel.h
+@interface ExampleObjModel
+@property (strong, nonatomic) NSString* banner;
+@property (strong, nonatomic) NSString* name;
+@property (assign, nonatomic) NSInteger count;
+@end
+```
+
+#### Caveats
+
+* The following is omitted from the beginning of all JSON examples:
+
+```
+"$schema": "http://json-schema.org/draft-04/schema#",
+"type": "object",
+```
+
+* `.m` files are also omitted from all examples
+
+## License
+
+MIT.
+
+[JSONSchema]: http://json-schema.org/
+[JSONSchemaDraft4]: http://tools.ietf.org/html/draft-zyp-json-schema-04

data/bin/nidyx

@@ -0,0 +1,125 @@
+#!/usr/bin/env ruby
+
+require "optparse"
+require "nidyx"
+require "nidyx/version"
+require "nidyx/generator"
+
+###
+# help text
+###
+
+BANNER = <<END
+usage: nidyx [-h] [--version]
+       nidyx <schema> <class-prefix> [output-directory]
+             [-n] [-a author] [-c company] [-p project]
+             [--json-model] # objc specific
+
+END
+
+DESC = <<END
+
+Nidyx generates plain Objective-C models from JSON Schema. It can also generate
+models with JSONModel support.
+
+Examples
+========
+
+Bare minimum. Given a schema and a class prefix, generate models in the
+current directory:
+
+  $ nidyx example.json.schema ClassPrefix
+
+Specify an ouput directory:
+
+  $ nidyx example.json.schema ClassPrefix /path/to/output/directory
+
+Generate models with JSONModel support and all optional documentation:
+
+  $ nidyx example.json.schema ClassPrefix /path/to/output/directory \\
+    -j -a "Your Name" -c "Company Name" -p "Project Name"
+
+END
+
+###
+# option parsing
+###
+
+# defaults
+options = {
+  :comments => true,
+  :platform => "objc",
+  :objc => {
+    :json_model => false
+  }
+}
+
+opts = OptionParser.new do |o|
+  o.banner = BANNER
+
+  ###
+  # general generation options
+  ###
+
+  o.on("-a", "--author AUTHOR", "Author's name") do |a|
+    options[:author] = a
+  end
+
+  o.on("-c", "--company COMPANY", "Company's name") do |c|
+    options[:company] = c
+  end
+
+  o.on("-p", "--project PROJECT", "Project's name") do |p|
+    options[:project] = p
+  end
+
+  o.on("-n", "--no-comments", "Generate without header comments") do |n|
+    options[:comments] = false
+  end
+
+  ###
+  # objc generation options
+  ###
+
+  o.on("--json-model", "Generate with JSONModel support") do |j|
+    options[:objc][:json_model] = true
+  end
+
+  ###
+  # other
+  ###
+
+  o.on("-h", "--help", "Print usage information") do
+    puts o
+    exit
+  end
+
+  o.on("--version", "Print version") do
+    puts Nidyx::VERSION
+    exit
+  end
+
+  o.separator DESC
+end
+
+begin
+  opts.parse!
+rescue OptionParser::InvalidOption => e
+  puts e
+  puts opts
+  exit 1
+end
+
+if ARGV.size < 2
+  puts "Too few arguments." unless ARGV.empty?
+  puts opts
+  exit 1
+end
+
+options[:output_path] = ARGV[2]
+
+###
+# run
+###
+
+Nidyx::Generator.run(ARGV[0], ARGV[1], options)

data/lib/nidyx/common.rb

@@ -0,0 +1,54 @@
+module Nidyx
+  module Common
+    class NoObjectAtPathError < StandardError; end
+
+    CLASS_SUFFIX = "Model"
+    IGNORED_KEYS = "properties", "definitions"
+
+    def class_name(prefix, key)
+      if key
+        prefix + key.camelize + CLASS_SUFFIX
+      else
+        prefix + CLASS_SUFFIX
+      end
+    end
+
+    def class_name_from_path(prefix, path, schema)
+      override = object_at_path(path, schema)[NAME_OVERRIDE_KEY]
+      return class_name(prefix, override.camelize) if override
+
+      name = ""
+      path.each_index do |idx|
+        # skip ignored keys such as "properties" in the name
+        next if IGNORED_KEYS.include?(path[idx])
+        # skip the last key if we are using an override
+        next if override && (idx == path.length - 1)
+
+        obj = object_at_path(path[0..idx], schema)
+        if obj[NAME_OVERRIDE_KEY]
+          name << obj[NAME_OVERRIDE_KEY].camelize
+        else
+          name << path[idx].camelize
+        end
+      end
+
+      # append the override name to the end if present
+      name << override.camelize if override
+      class_name(prefix, name)
+    end
+
+    def object_at_path(path, schema)
+      obj = schema
+
+      begin
+        path.each { |p| obj = obj[p] }
+      rescue
+        raise NoObjectAtPathError, path
+      end
+
+      raise NoObjectAtPathError, path unless obj
+
+      obj
+    end
+  end
+end

data/lib/nidyx/core_ext/string.rb

@@ -0,0 +1,12 @@
+class String
+  # Inspired by (read: "Stolen from") Rails ActiveSupport::Inflector
+  def camelize(uppercase_first_letter = true)
+    s = self
+    if uppercase_first_letter
+      s = s.sub(/^[a-z\d]*/) { $&.capitalize }
+    else
+      s = s.sub(/^([A-Z_]|\w)/) { $&.downcase }
+    end
+    s.gsub(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{$2.capitalize}" }
+  end
+end

data/lib/nidyx/generator.rb

@@ -0,0 +1,17 @@
+require 'nidyx/reader'
+require 'nidyx/parser'
+require 'nidyx/mapper'
+require 'nidyx/output'
+
+module Nidyx
+  module Generator
+    extend self
+
+    def run(schema_path, model_prefix, options)
+      schema = Nidyx::Reader.read(schema_path)
+      raw_models = Nidyx::Parser.parse(model_prefix, schema, options)
+      models = Nidyx::Mapper.map(raw_models, options)
+      Nidyx::Output.write(models, options[:output_path])
+    end
+  end
+end

data/lib/nidyx/mapper.rb

@@ -0,0 +1,19 @@
+require 'nidyx/objc/mapper'
+
+module Nidyx
+  module Mapper
+    extend self
+
+    # Proxies model mapping to the proper platform mapper
+    # @param models [Hash] a hash with model name keys and Model values
+    # @param options [Hash] runtime options
+    # @return [Array] an array of models generated for a specific platform
+    def map(models, options)
+      models = models.values
+      case options[:platform].downcase
+      when "objc", "obj-c", "objective-c"
+        Nidyx::ObjCMapper.map(models, options)
+      end
+    end
+  end
+end

data/lib/nidyx/model.rb

@@ -0,0 +1,12 @@
+module Nidyx
+  class Model
+    attr_accessor :properties, :dependencies
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+      @properties = []
+      @dependencies = Set.new
+    end
+  end
+end

data/lib/nidyx/objc/implementation.rb

@@ -0,0 +1,33 @@
+require "nidyx/objc/model_base"
+
+module Nidyx
+  class ObjCImplementation < ObjCModelBase
+    self.template_file = File.join(self.template_path, "implementation.mustache")
+
+    attr_accessor :name_overrides
+
+    def initialize(name, options)
+      super
+      self.file_name = "#{name}.#{EXT}"
+      self.imports = [name]
+    end
+
+    def name_overrides?
+      !self.name_overrides.empty?
+    end
+
+    def name_override_string
+      string = ""
+      count = 0
+      name_overrides.each do |original, override|
+        count += 1
+        string += "@\"#{original}\": @\"#{override}\""
+        string += ",\n" unless count == name_overrides.length
+      end
+      string
+    end
+
+    private
+    EXT = "m"
+  end
+end

data/lib/nidyx/objc/interface.rb

@@ -0,0 +1,20 @@
+require "nidyx/objc/model_base"
+
+module Nidyx
+  class ObjCInterface < ObjCModelBase
+    attr_accessor :properties
+
+    self.template_file = File.join(self.template_path, "interface.mustache")
+
+    def initialize(name, options)
+      super
+      self.file_name = "#{name}.#{EXT}"
+      self.imports << JSON_MODEL_IMPORT if self.json_model
+    end
+
+    private
+    EXT = "h"
+    JSON_MODEL_IMPORT = "JSONModel"
+
+  end
+end

data/lib/nidyx/objc/mapper.rb

@@ -0,0 +1,44 @@
+require "set"
+require "nidyx/objc/model"
+require "nidyx/objc/interface"
+require "nidyx/objc/implementation"
+require "nidyx/objc/property"
+
+module Nidyx
+  module ObjCMapper
+    extend self
+
+    # Generates a list of ObjCModels
+    # @param models [Array] an array of generic Models to map
+    # @param options [Hash] runtime options
+    # @return [Array] a list of ObjCModels
+    def map(models, options)
+      objc_models = []
+
+      models.each do |m|
+        interface = map_interface(m, options)
+        implementation = map_implementation(m, options)
+        objc_models << Nidyx::ObjCModel.new(interface, implementation)
+      end
+
+      objc_models
+    end
+
+    private
+
+    def map_interface(model, options)
+      interface = Nidyx::ObjCInterface.new(model.name, options)
+      interface.properties = model.properties.map { |p| Nidyx::ObjCProperty.new(p) }
+      interface.imports += model.dependencies.to_a
+      interface
+    end
+
+    def map_implementation(model, options)
+      implementation = Nidyx::ObjCImplementation.new(model.name, options)
+      name_overrides = {}
+      model.properties.each { |p| name_overrides[p.overriden_name] = p.name if p.overriden_name }
+      implementation.name_overrides = name_overrides
+      implementation
+    end
+  end
+end

data/lib/nidyx/objc/model.rb

@@ -0,0 +1,12 @@
+module Nidyx
+  class ObjCModel
+    def initialize(interface, implementation)
+      @interface = interface
+      @implementation = implementation
+    end
+
+    def files
+      [@interface, @implementation]
+    end
+  end
+end

data/lib/nidyx/objc/model_base.rb

@@ -0,0 +1,31 @@
+require "mustache"
+
+module Nidyx
+  class ObjCModelBase < Mustache
+    attr_accessor :name, :file_name, :author, :owner, :project, :imports, :comments, :json_model
+
+    self.template_path = File.join(__FILE__, "../../../../templates/objc")
+
+    def initialize(name, options)
+      @name = name
+      @author = options[:author]
+      @owner = options[:company]
+      @project = options[:project]
+      @comments = options[:comments]
+      @json_model = options[:objc][:json_model] if options[:objc]
+      @imports = []
+    end
+
+    def has_imports?
+      !self.imports.empty?
+    end
+
+    def no_owner?
+      !self.owner
+    end
+
+    def json_model?
+      self.json_model
+    end
+  end
+end