api_sketch 0.1.1 → 0.1.2

data/lib/api_sketch/dsl.rb

@@ -1,5 +1,7 @@
 class ApiSketch::DSL
 
+  attr_reader :definitions_dir
+
   COMPLEX_ATTRIBUTE_NAMES = [:headers, :parameters, :responses]
 
   def initialize(definitions_dir=ApiSketch::Config[:definitions_dir])
@@ -7,170 +9,18 @@ class ApiSketch::DSL
   end
 
   def init!
-    Dir.glob("#{@definitions_dir}/**/*.rb").each do |file_path|
-      puts_info("\t read: #{file_path}")
-      binding.eval(File.open(File.expand_path(file_path)).read, file_path)
-    end
-  end
-
-  class AttributeParser
-
-    def initialize(container_type, &block)
-      @attribute_values = {}
-      @container_type = container_type
-      # INFO: Such long method name is used to ensure that we are would not have such value as key at hash
-      define_singleton_method(:set_attributes_as_hash_value_format, block)
-      set_attributes_as_hash_value_format
-    end
-
-    def method_missing(method_name, *arguments, &block)
-      @attribute_values[method_name] = arguments.first || block
-    end
-
-    def to_h
-      @attribute_values
-    end
-
-  end
-
-
-  class Attributes
-
-    TYPES = [:integer, :string, :float, :boolean, :datetime, :timestamp, :document, :array]
-
-    def initialize(container_type, &block)
-      @container_type = container_type
-      @params = []
-      define_singleton_method(:initialize_attributes, block)
-      initialize_attributes
-    end
-
-    def to_a
-      @params
+    if File.directory?(config_dir)
+      puts_info("Load configuration")
+      load_dir_files(config_dir)
     end
 
-    def shared(name)
-      self.instance_eval(&::ApiSketch::Model::SharedBlock.find(name))
+    if File.directory?(resources_dir)
+      puts_info("Load resources")
+      load_dir_files(resources_dir)
     end
-
-    TYPES.each do |type_name|
-      define_method(type_name) do |*args, &block|
-        name = args.first
-        if @container_type == :document
-          if name.nil? || name.empty? # key name is not provided
-            raise ::ApiSketch::Error.new, "Key inside document should have name"
-          end
-        elsif @container_type == :array
-          if (!name.nil? && !name.empty?) # key name is provided
-            raise ::ApiSketch::Error.new, "Array element can't have name"
-          end
-        end
-        @params << self.class.build_by(type_name, name, &block)
-      end
-    end
-
-    class << self
-      def build_by(data_type, attribute_name, &block)
-        options = {data_type: data_type}
-        options[:name] = attribute_name if attribute_name
-        case data_type
-        when :document, :array
-          ::ApiSketch::Model::Attribute.new(::ApiSketch::DSL::ComplexAttributeParser.new(data_type, &block).to_h.merge(options))
-        else
-          ::ApiSketch::Model::Attribute.new(::ApiSketch::DSL::AttributeParser.new(data_type, &block).to_h.merge(options))
-        end
-      end
-    end
-
-  end
-
-  class ComplexAttributeParser < ApiSketch::DSL::AttributeParser
-
-    def method_missing(method_name, *arguments, &block)
-      if method_name == :content
-        @attribute_values[:content] = ApiSketch::DSL::Attributes.new(@container_type, &block).to_a
-      else
-        super(method_name, *arguments, &block)
-      end
-    end
-
   end
 
-
-  class Headers
-
-    def initialize(&block)
-      @list = []
-      define_singleton_method(:initialize_headers_list, block)
-      initialize_headers_list
-    end
-
-    def to_a
-      @list
-    end
-
-    def add(name, &block)
-      @list << ::ApiSketch::Model::Header.new(::ApiSketch::DSL::AttributeParser.new(:document, &block).to_h.merge(name: name))
-    end
-
-  end
-
-  class Parameters
-
-    def initialize(&block)
-      @query = []
-      @body = []
-      @query_container_type = nil
-      @body_container_type = nil
-      define_singleton_method(:initialize_parameters_list, block)
-      initialize_parameters_list
-    end
-
-    def to_h
-      {
-        query: @query,
-        body: @body,
-        query_container_type: @query_container_type,
-        body_container_type: @body_container_type
-      }
-    end
-
-    def query(container_type, &block)
-      @query_container_type = container_type
-      @query += ::ApiSketch::DSL::Attributes.new(container_type, &block).to_a
-    end
-
-    def body(container_type, &block)
-      @body_container_type = container_type
-      @body += ::ApiSketch::DSL::Attributes.new(container_type, &block).to_a
-    end
-
-  end
-
-  class Responses
-
-    def initialize(&block)
-      @list = []
-      define_singleton_method(:initialize_responses_list, block)
-      initialize_responses_list
-    end
-
-    def to_a
-      @list
-    end
-
-    def context(name, &block)
-      attributes = ::ApiSketch::DSL::AttributeParser.new(:root, &block).to_h
-      if attributes[:parameters]
-        params = ::ApiSketch::DSL::Parameters.new(&attributes[:parameters]).to_h
-        attributes[:parameters] = ::ApiSketch::Model::Parameters.new(params)
-      end
-      @list << ::ApiSketch::Model::Response.new(attributes.merge(name: name))
-    end
-
-  end
-
-  def shared_block(name, block)
+  def shared_block(name, &block)
     ::ApiSketch::Model::SharedBlock.add(name, block)
   end
 
@@ -183,16 +33,12 @@ class ApiSketch::DSL
     end
 
     # Assign resource namespace
-    attributes[:namespace] ||= block.source_location[0].gsub(definitions_dir, "").gsub(".rb", "").split("/").reject { |ns| ns.nil? || ns == "" }.join("/")
+    attributes[:namespace] ||= block.source_location[0].gsub(resources_dir, "").gsub(".rb", "").split("/").reject { |ns| ns.nil? || ns == "" }.join("/")
 
     ::ApiSketch::Model::Resource.create(attributes)
   end
 
-
   private
-    def definitions_dir
-      @definitions_dir
-    end
 
     def get_attrs(name, &block)
       ::ApiSketch::DSL::AttributeParser.new(:root, &block).to_h.merge(name: name)
@@ -210,4 +56,20 @@ class ApiSketch::DSL
       end
     end
 
-end
+    # Definitions loading
+    def config_dir
+      "#{definitions_dir}/config"
+    end
+
+    def resources_dir
+      "#{definitions_dir}/resources"
+    end
+
+    def load_dir_files(dir)
+      Dir.glob("#{dir}/**/*.rb").each do |file_path|
+        puts_info("\t read: #{file_path}")
+        binding.eval(File.open(File.expand_path(file_path)).read, file_path)
+      end
+    end
+
+end

data/lib/api_sketch/examples_server.rb

@@ -25,7 +25,7 @@ class ApiSketch::ExamplesServer
 
           response.status = Rack::Utils.status_code(api_response.http_status)
 
-          response.write(ApiSketch::ResponseRenderer.new(api_response.parameters.body, api_response.parameters.body_container_type, get_elements_count).to_json)
+          response.write(ApiSketch::ResponseRenderer.new([api_response.parameters.wrapped_body], api_response.parameters.body_container_type, get_elements_count).to_json)
         end
       else
         api_sketch_message("No any responses defined for this resource and context", 404)

data/lib/api_sketch/generators/base.rb

@@ -0,0 +1,42 @@
+module ApiSketch::Generators
+  class Base
+
+    attr_accessor :definitions_dir, :documentation_dir
+
+    attr_reader :templates_folder
+
+    # TODO: Add here some validations for folders existance, etc
+    def initialize(options = {})
+      self.definitions_dir = options[:definitions_dir]
+      self.documentation_dir = options[:documentation_dir]
+      @templates_folder = File.expand_path("../templates/#{self.class.name.split("::").last.downcase}", File.dirname(__FILE__))
+    end
+
+    def generate!
+      puts_info("Load definitions")
+      load_definitions
+      puts_info("Create documentation directory")
+      puts_info("\t path: #{self.documentation_dir}")
+      create_documentation_directory
+      puts_info("Create documentation files")
+      create_documentation_files
+    end
+
+    private
+      def create_documentation_directory
+        FileUtils.rm_r(self.documentation_dir, :force => true)
+        FileUtils.mkdir_p(self.documentation_dir)
+      end
+
+      # TODO: This is unfinished sample file generator it should be more complex at some other generators
+      #       Other generors should inherit from this class and implement this method
+      def create_documentation_files
+        raise "This method should be implemented at child class who inherits from ApiSketch::Generators::Base"
+      end
+
+      def load_definitions
+        ApiSketch::Model::Resource.reload!(self.definitions_dir)
+      end
+
+  end
+end

data/lib/api_sketch/{generators.rb → generators/bootstrap.rb}

@@ -1,52 +1,9 @@
 module ApiSketch::Generators
-
-  class Base
-
-    attr_accessor :definitions_dir, :documentation_dir
-
-    attr_reader :templates_folder
-
-    # TODO: Add here some validations for folders existance, etc
-    def initialize(options = {})
-      self.definitions_dir = options[:definitions_dir]
-      self.documentation_dir = options[:documentation_dir]
-      @templates_folder = File.expand_path("templates/#{self.class.name.split("::").last.downcase}", File.dirname(__FILE__))
-    end
-
-    def generate!
-      puts_info("Load definitions")
-      load_definitions
-      puts_info("Create documentation directory")
-      puts_info("\t path: #{self.documentation_dir}")
-      create_documentation_directory
-      puts_info("Create documentation files")
-      create_documentation_files
-    end
-
-    private
-      def create_documentation_directory
-        FileUtils.rm_r(self.documentation_dir, :force => true)
-        FileUtils.mkdir_p(self.documentation_dir)
-      end
-
-      # TODO: This is unfinished sample file generator it should be more complex at some other generators
-      #       Other generors should inherit from this class and implement this method
-      def create_documentation_files
-        raise "This method should be implemented at child class who inherits from ApiSketch::Generators::Base"
-      end
-
-      def load_definitions
-        ApiSketch::Model::Resource.reload!(self.definitions_dir)
-      end
-
-  end
-
-
   class Bootstrap < ApiSketch::Generators::Base
 
     # Generated folders structure is
-    # 	docs - html folders and files
-    # 	assets - js, css and images. Html styling
+    #   docs - html folders and files
+    #   assets - js, css and images. Html styling
 
     def initialize(options = {})
       super(options)
@@ -93,5 +50,4 @@ module ApiSketch::Generators
         end
       end
   end
-
 end

data/lib/api_sketch/model/attribute.rb

@@ -0,0 +1,42 @@
+class ApiSketch::Model::Attribute < ApiSketch::Model::Base
+  attr_accessor :data_type, :value, :example, :required, :default, :content
+
+  def example_value(defaults_allowed=false)
+    value = self.example
+    value ||= example_value_default if defaults_allowed
+
+    value.respond_to?(:call) ? value.call : value
+  end
+
+  # TODO: These default values should be configurable via DSL
+  #       Some logic to defer value example from key name, - email from key with email part inside, etc.
+  def example_value_default
+    {
+      integer:   lambda { rand(1000) + 1 },
+      string:    lambda { "random_string_#{('A'..'Z').to_a.shuffle.first(8).join}" },
+      float:     lambda { rand(100) + rand(100) * 0.01 },
+      boolean:   lambda { [true, false].sample },
+      datetime:  lambda { Time.now.strftime("%d-%m-%Y %H:%M:%S") },
+      timestamp: lambda { Time.now.to_i }
+    }[data_type]
+  end
+
+  def to_hash
+    {
+      data_type: self.data_type,
+      example_value: self.example_value,
+      required: !!self.required,
+      default: self.default,
+      content: self.content_to_hash
+    }
+  end
+
+  def content_to_hash
+    if self.content
+      self.content.map do |item|
+        item.to_hash
+      end
+    end
+  end
+
+end

data/lib/api_sketch/model/base.rb

@@ -0,0 +1,17 @@
+class ApiSketch::Model::Base
+
+  attr_accessor :name, :description
+
+  def initialize(attributes = {})
+    attributes = default_values_hash.merge(attributes)
+    attributes.each do |attribute, value|
+      self.send("#{attribute}=", value)
+    end
+  end
+
+  private
+    def default_values_hash
+      {}
+    end
+
+end

data/lib/api_sketch/model/header.rb

@@ -0,0 +1,7 @@
+class ApiSketch::Model::Header < ApiSketch::Model::Base
+  attr_accessor :value, :example, :required
+
+  def example_value
+    self.example.respond_to?(:call) ? self.example.call : self.example
+  end
+end

data/lib/api_sketch/model/parameters.rb

@@ -0,0 +1,50 @@
+class ApiSketch::Model::Parameters < ApiSketch::Model::Base
+  attr_accessor :query, :body, :query_container_type, :body_container_type
+
+  def initialize(attributes = {})
+    super(attributes)
+    self.query ||= []
+    self.body ||= []
+  end
+
+  def wrapped_query
+    ApiSketch::Model::Attribute.new(data_type: self.query_container_type, content: self.query)
+  end
+
+  def wrapped_body
+    ApiSketch::Model::Attribute.new(data_type: self.body_container_type, content: self.body)
+  end
+
+  def as_full_names
+    fullname_params = self.class.new
+    [:query, :body].each do |param_location|
+      new_params = []
+      self.send(param_location).each do |param|
+        if param.data_type == :document
+          full_names_for(param, param.name, new_params)
+        else
+          new_params << param
+        end
+      end
+      fullname_params.send("#{param_location}=", new_params)
+    end
+    fullname_params
+  end
+
+  private
+    def full_names_for(param, name = "", new_params)
+      name = name.to_s # ensure that this value is always a string
+      if param.content.kind_of?(Array)
+        param.content.each do |attribute|
+          renamed_attribute = attribute.clone
+          renamed_attribute.name = name.empty? ? attribute.name.to_s : "#{name}[#{attribute.name}]"
+          if renamed_attribute.data_type == :document
+            full_names_for(renamed_attribute, renamed_attribute.name, new_params)
+          else
+            new_params << renamed_attribute
+          end
+        end
+      end
+    end
+end
+

data/lib/api_sketch/model/resource.rb

@@ -0,0 +1,99 @@
+class ApiSketch::Model::Resource < ApiSketch::Model::Base
+
+  attr_accessor :namespace, :action, :path, :http_method, :format, :headers, :parameters, :responses
+
+  # TODO: update this method to provide better id that is used as part of filename
+  def id
+    [self.namespace, self.action].reject { |v| v.nil? || v == "" }.join("/")
+  end
+
+  class << self
+
+    def create(attributes)
+      res = self.new(attributes)
+      res.send(:run_validations!)
+      self.add(res)
+      res
+    end
+
+    def add(resource)
+      @resources ||= []
+      @resources << resource
+    end
+
+    def reset!
+      @resources = []
+    end
+
+    def reload!(definitions_dir)
+      ApiSketch::Model::SharedBlock.reset!
+      self.reset!
+      ApiSketch::DSL.new(definitions_dir).init!
+    end
+
+    def all
+      @resources ||= []
+    end
+
+    def find(id)
+      self.all.find { |res| res.id == id }
+    end
+
+    def find_by_http_method_and_path(http_method, path)
+      self.all.find { |res| res.http_method == http_method && res.path == path }
+    end
+
+    def first
+      self.all.first
+    end
+
+    def last
+      self.all.last
+    end
+
+    def count
+      self.all.count
+    end
+
+  end
+
+  private
+    def default_values_hash
+      {
+        http_method: "GET",
+        format: "json",
+        headers: [],
+        parameters: ::ApiSketch::Model::Parameters.new,
+        responses: []
+      }
+    end
+
+    def error_message(message)
+      # puts_error(message)
+      raise ::ApiSketch::Error, message
+    end
+
+    def run_validations!
+      unless self.action =~ /\A\w*\z/
+        error_message("'#{self.action}' is invalid action value")
+      end
+
+      if self.class.find(self.id)
+        error_message("'#{self.id}' is not unique id. Change values of 'namespace' and/or 'action' attributes")
+      end
+
+      if self.http_method.nil? || self.http_method.empty?
+        error_message("request http_method can't be blank")
+      end
+
+      if self.path.nil? || self.path.empty?
+        error_message("request path can't be blank")
+      end
+
+      if self.class.find_by_http_method_and_path(self.http_method, self.path)
+        error_message("Route '#{self.http_method} #{self.path}' should be unique")
+      end
+    end
+
+end
+

data/lib/api_sketch/model/response.rb

@@ -0,0 +1,12 @@
+class ApiSketch::Model::Response < ApiSketch::Model::Base
+  attr_accessor :http_status, :parameters, :format, :headers
+
+  private
+    def default_values_hash
+      {
+        format: "json",
+        headers: [],
+        parameters: ::ApiSketch::Model::Parameters.new
+      }
+    end
+end

data/lib/api_sketch/model/shared_block.rb

@@ -0,0 +1,17 @@
+module ApiSketch::Model::SharedBlock
+  @list_hash = {}
+
+  class << self
+    def add(name, block)
+      @list_hash[name] = block
+    end
+
+    def reset!
+      @list_hash = {}
+    end
+
+    def find(name)
+      @list_hash[name] || raise(::ApiSketch::Error, "Shared block '#{name}' is not defined")
+    end
+  end
+end