nidyx 0.1.0

data/lib/nidyx/objc/property.rb

@@ -0,0 +1,174 @@
+require "set"
+
+module Nidyx
+  class ObjCProperty
+    attr_reader :name, :attributes, :type, :type_name, :desc, :getter_override,
+                :protocols
+
+    class UnsupportedEnumTypeError < StandardError; end
+
+    # @param property [Property] generic property
+    def initialize(property)
+      @name = property.name
+      @optional = property.optional
+      @desc = property.description
+
+      @getter_override = process_getter_override(name)
+      @type = process_type(property)
+      @attributes = ATTRIBUTES[@type]
+      @type_name = lookup_type_name(@type, property.class_name)
+
+      @protocols = []
+      @protocols += property.collection_types if property.collection_types
+      @protocols << "Optional" if @optional
+    end
+
+    # @return [Boolean] true if the obj-c property type is an object
+    def is_obj?
+      OBJECTS.include?(self.type)
+    end
+
+    # @return [Boolean] true if the property has protocols
+    def has_protocols?
+      !@protocols.empty?
+    end
+
+    # @return [String] the property's protocols, comma separated
+    def protocols_string
+      @protocols.join(", ")
+    end
+
+    private
+
+    PRIMITIVE_ATTRIBUTES = "assign, nonatomic"
+    OBJECT_ATTRIBUTES = "strong, nonatomic"
+
+    ATTRIBUTES = {
+      :array      => OBJECT_ATTRIBUTES,
+      :boolean    => PRIMITIVE_ATTRIBUTES,
+      :integer    => PRIMITIVE_ATTRIBUTES,
+      :unsigned   => PRIMITIVE_ATTRIBUTES,
+      :number     => PRIMITIVE_ATTRIBUTES,
+      :number_obj => OBJECT_ATTRIBUTES,
+      :string     => OBJECT_ATTRIBUTES,
+      :object     => OBJECT_ATTRIBUTES,
+      :id         => OBJECT_ATTRIBUTES
+    }
+
+    # Objective-C types
+    # :object intentionally omitted
+    TYPES = {
+      :array      => "NSArray",
+      :boolean    => "BOOL",
+      :integer    => "NSInteger",
+      :unsigned   => "NSUInteger",
+      :number     => "double",
+      :number_obj => "NSNumber",
+      :string     => "NSString",
+      :id         => "id"
+    }
+
+    # Hash and Array intentionally omitted
+    ENUM_TYPES = {
+      Fixnum     => :integer,
+      String     => :string,
+      NilClass   => :null,
+      Float      => :number,
+      TrueClass  => :boolean,
+      FalseClass => :boolean
+    }
+
+    OBJECTS = Set.new [:array, :number_obj, :string, :object, :id]
+
+    SIMPLE_NUMBERS = Set.new [:unsigned, :integer, :number]
+
+    BOXABLE_NUMBERS = SIMPLE_NUMBERS + [:boolean]
+
+    FORBIDDEN_PROPERTY_PREFIXES = ["new", "copy"]
+
+    # @param type [Symbol] an obj-c property type
+    # @param class_name [String] an object's type name
+    # @return [String] the property's type name
+    def lookup_type_name(type, class_name)
+      type == :object ? class_name : TYPES[type]
+    end
+
+    # @param property [Property] generic property
+    # @return [Symbol] an obj-c property type
+    def process_type(property)
+      return process_enum_type(property) if property.enum
+
+      type = property.type
+      if type.is_a?(Set)
+        process_array_type(type, property)
+      else
+        process_simple_type(type, property)
+      end
+    end
+
+
+    # @param property [Property] generic property
+    # @return [Symbol] an obj-c property type
+    def process_enum_type(property)
+      enum = property.enum
+
+      # map enum to a set of types
+      types = enum.map { |a| a.class }
+      raise UnsupportedEnumTypeError unless (types & [ Array, Hash ]).empty?
+      types = Set.new(types.map { |t| ENUM_TYPES[t] })
+
+      process_array_type(types, property)
+    end
+
+    # @param type [Symbol] a property type symbol
+    # @param property [Property] generic property
+    # @return [Symbol] an obj-c property type
+    def process_simple_type(type, property)
+      case type
+      when :boolean, :number, :integer
+        return :number_obj if @optional
+        if type == :integer && property.minimum && property.minimum >= 0
+          return :unsigned
+        end
+        type
+
+      when :null
+        @optional = true
+        :id
+
+      when :object
+        property.has_properties? ? :object : :id
+
+      else
+        type
+      end
+    end
+
+    # @param type [Set] an array of property types
+    # @param property [Property] generic property
+    # @return [Symbol] an obj-c property type
+    def process_array_type(types, property)
+      # if the key is optional
+      @optional = true if types.delete?(:null)
+
+      # single optional type
+      return process_simple_type(types.to_a.shift, property) if types.size == 1
+
+      # conjoined number types
+      return :number if types.subset?(SIMPLE_NUMBERS) && !@optional
+      return :number_obj if types.subset?(BOXABLE_NUMBERS)
+
+      :id
+    end
+
+    # @param name [String] the property name
+    # @return [String, nil] the getter override string if necessary
+    def process_getter_override(name)
+      FORBIDDEN_PROPERTY_PREFIXES.each do |p|
+        return ", getter=get#{name.camelize}" if name.match(/^#{p}[_A-Z].*/)
+      end
+
+      nil
+    end
+  end
+end

data/lib/nidyx/output.rb

@@ -0,0 +1,25 @@
+module Nidyx
+  module Output
+    extend self
+
+    # @param models [Hash] a full hash of models to output
+    # @param dir [String] output directory, defaults to current directory
+    def write(models, dir)
+      path = dir || Dir.getwd
+      models.each { |model| write_file(model, path) }
+    end
+
+    private
+
+    # @param model [Hash] all of the files for a specific model, stored in
+    # @param path [String] output directory
+    # a hash by extension
+    def write_file(model, path)
+      model.files.each do |file|
+        File.open(File.join(path, file.file_name), "w") do |f|
+          f.puts file.render
+        end
+      end
+    end
+  end
+end

data/lib/nidyx/parse_constants.rb

@@ -0,0 +1,29 @@
+module Nidyx
+  module ParseConstants
+
+    ###
+    # Schema key definitions
+    ###
+    REF_KEY              = "$ref"
+    ENUM_KEY             = "enum"
+    TYPE_KEY             = "type"
+    DESCRIPTION_KEY      = "description"
+    REQUIRED_KEY         = "required"
+    PROPERTIES_KEY       = "properties"
+    NAME_OVERRIDE_KEY    = "nameOverride"
+    ITEMS_KEY            = "items"
+    MINIMUM_KEY          = "minimum"
+
+    ###
+    # Internal schema key definitions
+    ###
+    DERIVED_NAME         = "__derivedName"
+    COLLECTION_TYPES_KEY = "__collectionTypes"
+
+    ###
+    # Object types
+    ###
+    OBJECT_TYPE = "object"
+    ARRAY_TYPE  = "array"
+  end
+end

data/lib/nidyx/parser.rb

@@ -0,0 +1,188 @@
+require "nidyx/common"
+require "nidyx/parse_constants"
+require "nidyx/property"
+require "nidyx/pointer"
+require "nidyx/model"
+
+include Nidyx::Common
+include Nidyx::ParseConstants
+
+module Nidyx
+  module Parser
+    extend self
+
+    class UnsupportedSchemaError < StandardError; end
+
+    # @param model_prefix [String] the prefix for model names
+    # @param schema [Hash] JSON Schema
+    # @param options [Hash] global application options
+    # @return [Hash] a Hash of ModelData objects
+    def parse(model_prefix, schema, options)
+      # setup parser
+      @class_prefix = model_prefix
+      @options = options
+      @schema = schema
+      @models = {}
+
+      # run model generation
+      generate([], class_name(@class_prefix, nil))
+      @models
+    end
+
+    private
+
+    # Generates a Model and adds it to the models array.
+    # @param path [Array] the path to an object in the schema
+    # @param name [String] raw model name
+    def generate(path, name)
+      object = get_object(path)
+
+      type = object[TYPE_KEY]
+      if type == OBJECT_TYPE
+        generate_object(path, name)
+
+      elsif type == ARRAY_TYPE
+        generate_top_level_array(path)
+
+      elsif type.is_a?(Array)
+        if type.include?(OBJECT_TYPE)
+          raise UnsupportedSchemaError if type.include?(ARRAY_TYPE)
+          generate_object(path, name)
+
+        elsif type.include?(ARRAY_TYPE)
+          generate_top_leve_array(path)
+
+        else raise UnsupportedSchemaError; end
+      else raise UnsupportedSchemaError; end
+    end
+
+    def generate_object(path, name)
+      @models[name] = model = Nidyx::Model.new(name)
+      required_properties = get_object(path)[REQUIRED_KEY]
+      properties_path = path + [PROPERTIES_KEY]
+
+      get_object(properties_path).keys.each do |key|
+        optional = is_optional?(key, required_properties)
+        property_path = properties_path + [key]
+        model.properties << generate_property(key, property_path, model, optional)
+      end
+    end
+
+    def generate_top_level_array(path)
+      resolve_array_refs(get_object(path))
+    end
+
+    # @param key [String] the key of the property in the JSON Schema
+    # @param path [Array] the path to the aforementioned object in the schema
+    # @param model [Property] the model that owns the property to be generated
+    # @param optional [Boolean] true if the property can be empty or null
+    def generate_property(key, path, model, optional)
+      obj = resolve_reference(path)
+      class_name = obj[DERIVED_NAME]
+
+      if include_type?(obj, OBJECT_TYPE) && obj[PROPERTIES_KEY]
+        model.dependencies << class_name
+      elsif include_type?(obj, ARRAY_TYPE)
+        obj[COLLECTION_TYPES_KEY] = resolve_array_refs(obj)
+        model.dependencies += obj[COLLECTION_TYPES_KEY]
+      end
+
+      name = obj[NAME_OVERRIDE_KEY] || key
+      property = Nidyx::Property.new(name, class_name, optional, obj)
+      property.overriden_name = key if obj[NAME_OVERRIDE_KEY]
+      property
+    end
+
+    # Given a path, which could be at any part of a reference chain, resolve
+    # the immediate schema object. This means:
+    #
+    # - if there is an imediate ref, follow it
+    # - inherit any schema information from the parent reference chain
+    # (unimplemented)
+    #
+    # If we are at the end of a chain, do the following:
+    #
+    # - generate a model for this object if necessary
+    # - add `class_name` to the immediate object when appropriate
+    # - return the immediate object
+    #
+    # @param path [Array] the path to an object in the schema
+    # @param parent [Hash, nil] the merged attributes of the parent reference chain
+    # @return [Hash] a modified schema object with inherited attributes from
+    # it's parents.
+    def resolve_reference(path, parent = nil)
+      obj = get_object(path)
+      ref = obj[REF_KEY]
+
+      # TODO: merge parent and obj into obj (destructive)
+
+      # If we find an immediate reference, chase it and pass the immediate
+      # object as a parent.
+      return resolve_reference_string(ref) if ref
+
+      # If we are dealing with an object, encode it's class name into the
+      # schema and generate it's model if necessary.
+      if include_type?(obj, OBJECT_TYPE) && obj[PROPERTIES_KEY]
+        obj[DERIVED_NAME] = class_name_from_path(@class_prefix, path, @schema)
+        generate(path, obj[DERIVED_NAME]) unless @models.has_key?(obj[DERIVED_NAME])
+      end
+
+      obj
+    end
+
+    # Resolves any references burried in the `items` property of an array
+    # definition. Returns a list of collection types in the array.
+    # @param obj [Hash] the array property schema
+    # @return [Array] list of types in the array
+    def resolve_array_refs(obj)
+      items = obj[ITEMS_KEY]
+      types = []
+
+      case items
+      when Array
+        items.each do |i|
+          resolve_reference_string(i[REF_KEY])
+          types << class_name_from_ref(i[REF_KEY])
+        end
+      when Hash
+        resolve_reference_string(items[REF_KEY])
+        types << class_name_from_ref(items[REF_KEY])
+      end
+
+      types.compact
+    end
+
+    def class_name_from_ref(ref)
+      class_name_from_path(@class_prefix, Nidyx::Pointer.new(ref).path, @schema) if ref
+    end
+
+    # Resolves a reference as a plain JSON Pointer string.
+    # @param ref [String] reference in json pointer format
+    # @return [Hash] a modified schema object with inherited attributes from
+    # it's parents.
+    def resolve_reference_string(ref)
+      resolve_reference(Nidyx::Pointer.new(ref).path) if ref
+    end
+
+    # @param path [Array] the path to an object in the global schema
+    # @return [Hash] a object containing JSON schema
+    def get_object(path)
+      object_at_path(path, @schema)
+    end
+
+    # @param key [String] the id of a specific property
+    # @param required_keys [Array] an array of the required property keys
+    # @return true if the property is optional
+    def is_optional?(key, required_keys)
+      !(required_keys && required_keys.include?(key))
+    end
+
+    # @param type_obj [Array, String] the JSON Schema type
+    # @param type [String] a string type to test
+    # @param true if the string type is a valid type according type object
+    def include_type?(obj, type)
+      type_obj = obj[TYPE_KEY]
+      type_obj.is_a?(Array) ? type_obj.include?(type) : type_obj == type
+    end
+  end
+end

data/lib/nidyx/pointer.rb

@@ -0,0 +1,17 @@
+# JSON Pointer
+module Nidyx
+  class Pointer
+    attr_reader :source, :path
+
+    def initialize(str)
+      match = /^(?<source>.*)#\/*(?<path>.*)$/.match(str)
+      @source = match[:source]
+      @path = match[:path].split("/")
+    end
+
+    def to_s
+      puts "source: #{source}"
+      puts "path: #{path}"
+    end
+  end
+end

data/lib/nidyx/property.rb

@@ -0,0 +1,52 @@
+require "set"
+require "nidyx/parse_constants"
+
+include Nidyx::ParseConstants
+
+module Nidyx
+  class Property
+    attr_accessor :overriden_name
+    attr_reader :name, :class_name, :optional, :type, :description, :enum,
+      :collection_types, :minimum
+
+    class UndefinedTypeError < StandardError; end
+    class NonArrayEnumError < StandardError; end
+    class EmptyEnumError < StandardError; end
+
+    def initialize(name, class_name, optional, obj)
+      @name = name.camelize(false)
+      @class_name = class_name
+      @optional = optional
+      @enum = obj[ENUM_KEY]
+      @type = process_type(obj[TYPE_KEY], @enum)
+      @description = obj[DESCRIPTION_KEY]
+      @properties = obj[PROPERTIES_KEY]
+      @collection_types = obj[COLLECTION_TYPES_KEY]
+      @minimum = obj[MINIMUM_KEY]
+    end
+
+    def has_properties?
+      !!@properties
+    end
+
+    private
+
+    def process_type(type, enum)
+      if enum
+        raise NonArrayEnumError unless @enum.is_a?(Array)
+        raise EmptyEnumError if @enum.empty?
+        return
+      end
+
+      case type
+      when Array
+        raise UndefinedTypeError if type.empty?
+        Set.new(type.map { |t| t.to_sym })
+      when String
+        type.to_sym
+      else
+        raise UndefinedTypeError
+      end
+    end
+  end
+end

data/lib/nidyx/reader.rb

@@ -0,0 +1,45 @@
+require "json"
+require "nidyx/parse_constants"
+
+include Nidyx::ParseConstants
+
+module Nidyx
+  module Reader
+    extend self
+
+    class EmptySchemaError < StandardError; end
+
+    # Reads JSON from a file
+    # @param path [String] path of the file to read
+    # @return [Hash] the parsed JSON
+    def read(path)
+      schema = nil
+
+      begin
+        # TODO: validate this is legitimate JSON Schema
+        schema = JSON.parse(IO.read(path))
+        raise EmptySchemaError if empty_schema?(schema)
+      rescue JSON::JSONError => e
+        puts "Encountered an error reading JSON from #{path}"
+        puts e.message
+        exit 1
+      rescue EmptySchemaError
+        puts "Schema read from #{path} is empty"
+        exit 1
+      rescue StandardError => e
+        puts e.message
+        exit 1
+      end
+
+      schema
+    end
+
+    # @param schema [Hash] an object containing JSON schema
+    # @return [Boolean] true if the schema is empty
+    def empty_schema?(schema)
+      props = schema[PROPERTIES_KEY]
+      items = schema[ITEMS_KEY]
+      (!props || props.empty?) && (!items || items.empty?)
+    end
+  end
+end

data/lib/nidyx/version.rb

@@ -0,0 +1,3 @@
+module Nidyx
+  VERSION = "0.1.0"
+end

data/lib/nidyx.rb

@@ -0,0 +1 @@
+require "nidyx/core_ext/string.rb"

data/test/nidyx/core_ext/test_string.rb

@@ -0,0 +1,40 @@
+require "minitest/autorun"
+require "nidyx"
+
+class TestCoreExt < Minitest::Test
+  def test_camelize
+    assert_equal("CamelCaseString", "camelCaseString".camelize)
+    assert_equal("CamelCaseString", "camel_case_string".camelize)
+    assert_equal("CamelCaseString", "Camel_Case_String".camelize)
+    assert_equal("CamelCaseString", "camel_Case_STRING".camelize)
+    assert_equal("1IsTheLoneliestNumber", "1_is_the_loneliest_number".camelize)
+    assert_equal("CCString", "CCString".camelize)
+  end
+
+  def test_camelize_with_optional_param
+    assert_equal("CamelCaseString", "camelCaseString".camelize(true))
+    assert_equal("camelCaseString", "CamelCaseString".camelize(false))
+    assert_equal("camelCaseString", "camel_case_string".camelize(false))
+    assert_equal("camelCaseString", "camel_case_string".camelize(false))
+    assert_equal("camelCaseString", "Camel_Case_String".camelize(false))
+    assert_equal("camelCaseString", "camel_Case_STRING".camelize(false))
+    assert_equal("1IsTheLoneliestNumber", "1_is_the_loneliest_number".camelize(false))
+  end
+
+  def test_camelize_unchanged
+    assert_equal("CamelCaseString", "CamelCaseString".camelize)
+    assert_equal("CamelCaseString", "CamelCaseString".camelize(true))
+    assert_equal("camelCaseString", "camelCaseString".camelize(false))
+  end
+
+  def test_camelize_with_plain_numbers
+    assert_equal("123121151", "123121151".camelize)
+    assert_equal("123121151", "123121151".camelize(false))
+  end
+
+  def test_camelize_not_destructive
+    string = "camel_case_string"
+    assert_equal("CamelCaseString", string.camelize)
+    assert_equal("camel_case_string", string)
+  end
+end

data/test/nidyx/objc/test_model_base.rb

@@ -0,0 +1,26 @@
+require "minitest/autorun"
+require "nidyx/objc/model_base"
+
+class TestModelBase < Minitest::Test
+
+  MOCK_OPTS = {
+    :author => "test_author",
+    :company => "test_company",
+    :project => "test_project"
+  }
+
+  def test_empty_options
+    model = Nidyx::ObjCModelBase.new("ModelName", {})
+    assert_equal("ModelName", model.name)
+    assert_equal(nil, model.author)
+    assert_equal(nil, model.owner)
+    assert_equal(nil, model.project)
+  end
+
+  def test_full_options
+    model = Nidyx::ObjCModelBase.new("ModelName", MOCK_OPTS)
+    assert_equal("test_author", model.author)
+    assert_equal("test_company", model.owner)
+    assert_equal("test_project", model.project)
+  end
+end