rest_kat 0.0.4

data/lib/rest_kat.rb

@@ -0,0 +1,342 @@
+module RestKit
+  class Resource
+    attr_accessor :hash
+    def initialize resource
+      self.hash = resource
+    end
+
+    def objc_resource_type
+      hash[:type][:name]
+    end
+
+    def objc_class
+      "MSRestResource#{hash[:name].camelize}"
+    end
+
+    def permissions
+      hash[:permissions]
+    end
+
+    def c_permission_for type
+      if permissions.include? type
+        "true"
+      else
+        "false"
+      end
+    end
+
+    def singleton?
+      @singleton ||= permissions.include? 's'
+    end
+
+    def create?
+      @create ||= permissions.include? 'c'
+    end
+
+    def read?
+      @read ||= permissions.include? 'r'
+    end
+
+    def update?
+      @update ||= permissions.include? 'u'
+    end
+
+    def delete?
+      @delete ||= permissions.include? 'd'
+    end
+
+    def queries &block
+      if hash.has_key?("queries")
+        if block_given?
+          hash["queries"].each &block 
+        else
+          hash["queries"]
+        end
+      else
+        []
+      end
+    end
+
+    def c_bool r
+      if r
+        "true"
+      else
+        "false"
+      end
+    end
+
+  end
+
+  class ObjCProperty
+    attr_accessor :klass
+    attr_accessor :name
+    def initialize(klass, name)
+      raise Exception.new(":klass parameter cannot be nil") unless klass
+      raise Exception.new(":name parameter cannot be nil") unless name
+      self.klass = klass
+      self.name = name
+    end
+  end
+
+  class ObjCClass
+    attr_accessor :properties
+    attr_accessor :sequence_of
+    attr_accessor :type
+    attr_accessor :parent
+    attr_accessor :json_type
+    attr_accessor :node
+    attr_accessor :resource
+
+    def objc_super_class
+      if resource
+        "MSRestSerializableResource"
+      else
+        "MSRestSerializable"
+      end
+    end
+
+    def complex?
+      map? || seq?
+    end
+
+    def map?
+      properties && (not properties.empty?)
+    end
+
+    def seq?
+      !!sequence_of
+    end
+
+    def objc_class
+      self.type
+    end
+
+    def enum?
+      (node["type"] == "str") && node.has_key?("enum")
+    end
+
+    def enum
+      node["enum"]
+    end
+
+    def objc_property_decl name
+      "@property (nonatomic, strong) #{objc_class} * #{name}"
+    end
+
+    def objc_property_arg_decl name
+      "#{name}: (#{objc_class} *) #{name}"
+    end
+
+    def objc_properites_arg_list_decl
+      properties.reject{|p| p.name == 'id'}.map do |p|
+        p.klass.objc_property_arg_decl p.name
+      end.join "\n   "
+    end
+
+    def initialize type, json_type, node
+      self.properties = nil
+      self.type = type
+      self.json_type = json_type
+      self.node = node
+    end
+
+  end
+
+  class IosMapping
+
+    def initialize api_schema
+        raise "#{api_schema} does not exist" unless File.exist?(api_schema)
+        @schema_file = api_schema
+    end
+
+    def resources_from_schema
+      schema[:resources]
+    end
+
+    def schema
+      require 'kwalify'
+      @schema ||= HashWithIndifferentAccess.new Kwalify::Yaml.load_file(@schema_file)
+    end
+
+    def classes
+      @classes ||= []
+    end
+
+    def resources
+      @resources ||= []
+    end
+
+    def template name
+      require 'erb'
+      ERB.new File.read(File.expand_path(File.join("..", name), __FILE__)), 0, '<>'
+    end
+
+    def h_template
+      template "model.h.erb"
+    end
+
+    def m_template
+      template "model.m.erb"
+    end
+
+    # Generate the required objective c class AST's for th +name+ resource in
+    # the correct order so they can be written to code in the correct order in
+    # the templates
+    def generate_objective_c_classes
+      @classes = []
+      resources_from_schema.collect do |resource_hash|
+        Resource.new(resource_hash).tap do |resource|
+          # Generate the query classes first
+          resource.queries.each do |query|
+            to_objective_c_class query["type"]
+          end
+          # Generate the resource classes next
+          klass = to_objective_c_class resource.hash[:type]
+          # Mark this class as being a REST resource
+          klass.resource = resource
+        end
+      end
+    end
+
+    # Generate the objective C header for +name+ resource
+    def to_h name
+      @resources = generate_objective_c_classes
+      h_template.result binding
+    end
+
+    # Generate the objective C implementation file for +name+ resource
+    def to_m name
+      @resources = generate_objective_c_classes
+      #TODO below 'header' must change
+      header = (File.basename name, ".*") + ".h"
+      m_template.result binding
+    end
+
+    def self.obj_c_type_for_property parent_node, property_name
+      parent_type = parent_node[:name].gsub /MSRest/, ''
+      "MSRest#{parent_type.camelize}#{property_name.camelize}"
+    end
+
+    def find_processed_class node
+      classes.find{|c| c.type == node[:name]}
+    end
+
+    # Perform a depth first traversal of the type tree. The resulting
+    # classes array will have the top level class last in the array. In
+    # the code generation phase this classes will be injected last into
+    # the code making sure the dependencies are define in the correct
+    # order.
+    def to_objective_c_class node
+      unless node
+        raise Exception.new("node is nil for name '#{name}'")
+      end
+
+      case node[:type]
+      when "map"
+
+        unless klass = find_processed_class(node)
+          klass = ObjCClass.new(node[:name], node[:type], node)
+
+          klass.properties = node[:mapping].collect do |property_name, property_node|
+            if property_node[:type] == "map"
+              property_node[:name] ||= IosMapping.obj_c_type_for_property(node, property_name)
+            end
+            ObjCProperty.new(to_objective_c_class(property_node), property_name)
+          end
+
+          self.classes << klass
+        end
+
+      when "seq"
+        klass = ObjCClass.new(node[:name] || "NSArray", node[:type], node)
+        if node[:sequence].length != 1
+          raise "Only support sequence of map with one map type"
+        end
+        sequence_node = node[:sequence].first
+        if sequence_node["type"] == "map"
+          if not sequence_node["name"]
+            raise Exception.new ("sequence of map nodes must have a :name to generate the objective C types")
+          end
+          klass.sequence_of = to_objective_c_class sequence_node
+        end
+      when "str", "text"
+        klass = ObjCClass.new(node[:name] || "NSString", node[:type], node)
+      when "int"
+        klass = ObjCClass.new(node[:name] || "NSNumber", node[:type], node)
+      when "float"
+        klass = ObjCClass.new(node[:name] || "NSNumber", node[:type], node)
+      when "bool"
+        klass = ObjCClass.new(node[:name] || "NSNumber", node[:type], node)
+      when "any"
+        klass = ObjCClass.new(node[:name] || "NSObject", node[:type], node)
+      else
+        raise Exception.new("Unhandled type '#{node[:type]} for node with name #{node[:name]}")
+      end
+
+      raise Exception.new("klass cannot be nil") unless klass
+
+      klass
+
+    end
+  end
+end
+
+module RestKat 
+
+    class MySugrIphone
+        class <<self
+            def root
+                ENV["MYSUGR_IPHONE_ROOT"]
+            end
+        end
+    end
+
+    def self.generate_item(api_location, schema_location, ext)
+        deps = %w[
+            model.h.erb
+            model.m.erb
+            rest_kat.rb
+            validator.rb
+        ].collect do |d|
+            File.expand_path "../#{d}", __FILE__
+        end
+
+        deps << schema_location
+
+        file = "#{api_location}.#{ext}"
+
+        file_task = Rake::FileTask.define_task file => deps do
+            File.open file, 'w' do |f|
+                puts "Generating #{file}"
+                f.write RestKit::IosMapping.new(schema_location).send("to_#{ext}", file)
+            end
+        end  
+    end
+
+    def self.generate_api(api_location, schema_location)
+
+        api_src = File.join api_location, "MSRestApiAutoGen"
+        m_file_task = generate_item(api_src, schema_location, "h")
+        h_file_task = generate_item(api_src, schema_location, "m")
+
+        src_path = File.expand_path "../../src", __FILE__
+
+        src_h = File.join src_path, "MSRestSerializable.h"
+        src_m = File.join src_path, "MSRestSerializable.m"
+
+        tgt_h = File.join api_location, "MSRestSerializable.h"
+        tgt_m = File.join api_location, "MSRestSerializable.m"
+
+
+        t0 = file tgt_h, src_h do
+            cp src_h, tgt_h, :verbose => true
+        end
+
+        t1 = file tgt_m, src_m do
+            cp src_m, tgt_m, :verbose => true
+        end
+
+        Rake::Task.define_task :type => [m_file_task, h_file_task, t0, t1]
+    end
+
+end

data/lib/validator.rb

@@ -0,0 +1,53 @@
+require 'kwalify'
+
+module RestKit
+  ## validator class for answers
+  class Validator < Kwalify::Validator
+    ## load schema definition
+    @@schema = Kwalify::Yaml.load_file(  File.join Rails.root, "lib/rest_kit/api_schema.yml" )
+    def self.schema
+      @@schema
+    end
+
+    def resource_schema
+      @resource_schema
+    end
+
+    def initialize type
+      super (@resource_schema=type)
+    end
+
+    def self.find_resource resource
+      Validator.schema["resources"].find do |r|
+        r["name"].to_s == resource.to_s
+      end
+    end
+
+    def self.for_resource resource
+      type = find_resource(resource)["type"]
+      raise Exception.new("Can't find resource '#{resource}'") unless type
+      pp type
+      Validator.new type
+    end
+
+    def self.for_type type
+      type = Validator.schema[type.to_s]
+      raise Exception.new("Can't find resource '#{resource}'") unless type
+      pp type
+      Validator.new type
+    end
+
+    def self.for_resource_collection resource
+      type = find_resource(resource)["type"]
+      raise Exception.new("Can't find resource '#{resource}'") unless type
+      collection_type = {
+        "type" => "seq",
+        "sequence" => [ type ]
+      }
+
+      Validator.new collection_type
+    end
+
+  end
+
+end

data/rest_kat.gemspec

@@ -0,0 +1,71 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rest_kat}
+  s.version = "0.0.4"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = [%q{Brad Phelan}]
+  s.date = %q{2011-11-18}
+  s.description = %q{The generated source code is a layer on top of the iOS REST framework http://restkit.org/}
+  s.email = %q{brad.phelan@mysugr.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    ".rvmrc",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.md",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "lib/model.h.erb",
+    "lib/model.m.erb",
+    "lib/rest_kat.rb",
+    "lib/tasks/iphone.rake",
+    "lib/validator.rb",
+    "rest_kat.gemspec",
+    "spec/rest_kat_spec.rb",
+    "spec/spec_helper.rb",
+    "src/MSRestSerializable.h",
+    "src/MSRestSerializable.m"
+  ]
+  s.homepage = %q{http://github.com/mysugr/rest_kat}
+  s.licenses = [%q{MIT}]
+  s.require_paths = [%q{lib}]
+  s.rubygems_version = %q{1.8.8}
+  s.summary = %q{Generate objective C RestKit boilerplate code from a yaml schema}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<kwalify>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+    else
+      s.add_dependency(%q<kwalify>, [">= 0"])
+      s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<kwalify>, [">= 0"])
+    s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+  end
+end
+

data/spec/rest_kat_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "RestKat" do
+  it "fails" do
+    fail "hey buddy, you should probably rename this file and start specing for real"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'rest_kat'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

data/src/MSRestSerializable.h

@@ -0,0 +1,79 @@
+//
+//  NSApiBase.h
+//  MySugr
+//
+//  Created by brad phelan on 10/4/11.
+//  Copyright (c) 2011 __MyCompanyName__. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "NSDate+APIDate.h"
+#import <RestKit/RestKit.h>
+
+@interface MSRestSerializable : NSObject<NSCopying>
+// The mapper for this instance
+- (RKObjectMapping *) _mapper;
+
+// The serializer for this instance
+- (RKObjectMapping *) _serializer;
+
+- (NSDictionary *)convertToDictionary;
+
+- (NSString *)convertToFormURLEncoded;
+
+- (NSString *)convertToJSON;
+
+- (BOOL)isNew;
+@end
+
+@interface MSRestSerializableResource : MSRestSerializable
+
+#pragma mark methods to be overridden
+
++ (Class) classForResource;
+
+// The resource path. If this 
++ (NSString *) resourcePath;
+
+// Is the resource a singleton or a collection
++ (bool) isSingleton;
+
+// Can the client create resources
++ (bool) canCreate;
+
+// Can the client read resources
++ (bool) canRead;
+
+// Can the client update resources
++ (bool) canUpdate;
+
+// Can the client delete resources
++ (bool) canDelete;
+
+#pragma mark helpers
+
+// The router for this class
++ (RKObjectRouter *) router;
+
+// Intialize the routing module. Must
+// be called from +initialize in a 
+// subclass or the logic will not
+// work.
++ (void) initializeRouting;
+
+
+// save the object
+-(void) saveWithDelegate:(id<RKObjectLoaderDelegate>)delegate;
+
+// Find an instance by id
++ (void) find:(NSNumber *)id 
+ withDelegate:(id<RKObjectLoaderDelegate>)delegate;
+
+// Load collection
++ (void) loadCollectionWithDelegate:(id<RKObjectLoaderDelegate>)delegate;
+
+// Load collection with query
++ (void) loadCollectionThroughQuery:(MSRestSerializable *)mappableQueryObject 
+                       withDelegate:(id<RKObjectLoaderDelegate>)delegate;
+
+@end