lit_doc 0.1.1.pre → 0.1.2.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5b2bf42a0be7604c9ea09d497743ffc04a04fc47
-  data.tar.gz: 809ea9a2ec38b4b5eddf3ff08ce922b259124f3a
+  metadata.gz: 75312356aaa43eea947262886fcfef1ce1f18f8c
+  data.tar.gz: 8a47d9a97d452baeca23775ea680cfb8faaac3c7
 SHA512:
-  metadata.gz: 1cd80387090c1641d05c04722ae6e6015bc8b2bf07c58b78a4f500d6410ac06be381ea2fb423acdd532604037c3d1498e37eeff5507273762b16022c8c3bf7ec
-  data.tar.gz: df3cb53f9d03be289ebb85fd01df17a91efef27a32d8d7ec159e3a99b58017ed43df402cf2e86409e5504dda80c60246ba89689bb5428f16cf9e3861956a31e9
+  metadata.gz: 6c5280fa971f932d50084cfc8681a0a45c994e76f0bb698c4c8f8192736b720a816be6caae324f66ee642b45273e12018f5f4c6d70d0ba528f595934f0c6c385
+  data.tar.gz: ee5e9df3b82e4e87830c5a246518d81dd37ac0be3391abb7a5aa7266bbc176ed1a99a8ca73c9466bc05cf2772de1a7d4aa20f1925047c51d1399ca20fa50ac43

data/README.md

@@ -23,7 +23,10 @@ or in rails gemfile
   * `@import "app/controllers/application_controller.rb"`
 3. run `rails lit_doc:generate` to generate a doc. You can find the result in doc/gen/generate.md.
 
-## End Goal Usage Scenario
+## Features to be Implemented
+- [ ] Allow specific response (res) and body (b) imports, for example @res-model-index and @b-serializer-create
+
+## Usage Example
 in source.md:
 
 have a mixture of markdown syntax and "@import 'rails.root/path_to_file'" statements
@@ -37,7 +40,7 @@ above each action that the user wishes to document, he/she will use the followin
 **NOTE:** Lit Doc syntax starts with 2 hashtags
 ``` ruby
 ## @h: header text
-## @r: http method route
+## @r: http_method route
 ## @b-model: path to model
 ## @b-serializer: path to serializer
 ## @res-model: path to model

data/lib/lit_doc/version.rb

@@ -1,3 +1,3 @@
 module LitDoc
-  VERSION = "0.1.1.pre"
+  VERSION = "0.1.2.pre"
 end

data/lib/modules/scanner.rb

@@ -6,14 +6,15 @@ module Scanner
   # [ { file: "file_path", header_sizes: {h: integer} } ]
   def read_source_file(file_path)
     file_paths_and_header_sizes = []
+    regular_markdown_lines = []
 
     File.open(file_path, "r").each_line do |line|
-      line.lstrip!
-      args = line.split(' ')
+      inspect_line = line.lstrip
+      args = inspect_line.split(' ')
       # puts "arguments in source.md: #{args}"
       if args[0] == "@import"
         # see if {h: 1} pattern exists
-        header_sizes = line[/{\s*h:\s*[0-9]\s*}/]
+        header_sizes = inspect_line[/{\s*h:\s*[0-9]\s*}/]
         header_hash = Hash.new
         # if user passed sizes
         if header_sizes
@@ -27,10 +28,12 @@ module Scanner
 
         hash = {file: file_path.gsub('"', ''), header_sizes: header_hash}
         file_paths_and_header_sizes.push(hash)
+      else
+        regular_markdown_lines.push(line)
       end
     end
 
-    return file_paths_and_header_sizes
+    return file_paths_and_header_sizes, regular_markdown_lines
   end
 
   # go through imported files and return lines that contain lit doc code
@@ -47,7 +50,7 @@ module Scanner
 
     file_paths_and_sizes.each do |path_and_size|
       lines_with_doc = []
-      
+
       File.open("#{root_path}/#{path_and_size[:file]}", "r").each_line do |line|
         # regex: lines that satisfy the following conditions:
         # 1. can start with a white space
@@ -71,20 +74,31 @@ module Scanner
 
     return lines_and_header_sizes
   end
+
+  def process_regular_markdown_lines(lines, generated_file_path)
+    File.open(generated_file_path, "a") do |f|
+      lines.each do |line|
+        f << "#{line}"
+      end
+    end
+  end
   ##############################################################################
   ### detect lit doc code and process it
   ### lit code syntax:
   ## @h: header text
-  ## @r: http method route
+  ## @r: http_method route
   ## @b-model: path to model
   ## @b-serializer: path to serializer
   ## @res-model: path to model
   ## @res-serializer: path to serializer
   ## regular markdown
-  def process_lines(files_and_header_sizes, generated_file_path)
+  def process_lit_doc_lines(files_and_header_sizes, generated_file_path)
     files_and_header_sizes.each do |entry|
       entry[:file][:lines].each do |line|
         args = line.split(' ')
+
+        File.open(generated_file_path, "a"){ |f| f << "\n" }
+
         case args[1]
         when "@h:"
           # puts "this is a header"
@@ -92,6 +106,11 @@ module Scanner
           args.shift(2)
           header_size = entry[:file][:sizes][:h]
           process_header(args, generated_file_path, header_size)
+        when "@r:"
+          # puts "this is a route"
+          # remove first 2 entries in array
+          args.shift(2)
+          process_route(args, generated_file_path)
         when "@b-model:"
           # puts "this is a body"
           # remove first 2 entries in array
@@ -102,6 +121,16 @@ module Scanner
           # remove first 2 entries in array
           args.shift(2)
           process_response_model(args, generated_file_path)
+        when "@b-serializer:"
+          # puts "this is a body"
+          # remove first 2 entries in array
+          args.shift(2)
+          process_body_serializer(args, generated_file_path)
+        when "@res-serializer:"
+          # puts "this is a response"
+          # remove first 2 entries in array
+          args.shift(2)
+          process_response_serializer(args, generated_file_path)
         else
           # puts "this is regular markdown"
           # remove first entry in array
@@ -113,10 +142,6 @@ module Scanner
   end
 
   private
-    ############################################################################
-    #### FORMAT:
-    # TODO user passes size of headers(number of # to print) when importing
-    #
     def process_header(args, file_path, header_size)
       # puts "args: #{args}"
       args = args.join(' ')
@@ -128,6 +153,16 @@ module Scanner
         f << "\n"
       end
     end
+    # args = http_method url
+    def process_route(args, file_path)
+
+      File.open(file_path, "a") do |f|
+        # write to file
+        str = "`#{args[0].upcase} #{args[1]}`"
+        f << str
+        f << "\n"
+      end
+    end
 
     def process_body_model(args, file_path)
       # puts "args: #{args}"
@@ -153,6 +188,30 @@ module Scanner
       end
     end
 
+    def process_body_serializer(args, file_path)
+      # puts "args: #{args}"
+      args = args.join(' ').strip
+      lines = scan_serializer_for_body(args)
+      File.open(file_path, "a") do |f|
+        lines.each do |l|
+          f << l
+          f << "\n"
+        end
+      end
+    end
+
+    def process_response_serializer(args, file_path)
+      # puts "args: #{args}"
+      args = args.join(' ').strip
+      lines = scan_serializer_for_response(args)
+      File.open(file_path, "a") do |f|
+        lines.each do |l|
+          f << l
+          f << "\n"
+        end
+      end
+    end
+
     def process_markdown(args, file_path)
       # puts "args: #{args}"
       args = args.join(' ')
@@ -170,15 +229,32 @@ module Scanner
     ## @b: body
     ## @res: response
     def scan_model_for_body(model_name)
-      return scan_model("@b:", model_name)
+      return scan_hash("@b:", "app/models/#{model_name.downcase}.rb")
     end
 
     def scan_model_for_response(model_name)
-     return scan_model("@res:", model_name)
+     return scan_hash("@res:", "app/models/#{model_name.downcase}.rb")
     end
 
-    def scan_model(switch, model_name)
-      path = "app/models/#{model_name.downcase}.rb"
+    ############################################################################
+    ####### GET RESPONSE AND BODY FROM SERIALIZER
+    ### detect lit doc code and process it
+    ### lit code syntax:
+    ## @h: header text
+    ## @b: body
+    ## @res: response
+    def scan_serializer_for_body(model_name)
+      return scan_hash("@b:", "app/serializers/#{model_name.downcase}.rb")
+    end
+
+    def scan_serializer_for_response(model_name)
+     return scan_hash("@res:", "app/serializers/#{model_name.downcase}.rb")
+    end
+
+    ############################################################################
+    ####### HELPER METHODS
+    # scans for hash and turns it to jason
+    def scan_hash(switch, path)
       scanned_docs = []
       read_doc_flag = false
       File.open(path, "r").each_line do |line|
@@ -188,9 +264,20 @@ module Scanner
           if args[1] == switch
             read_doc_flag = true
             scanned_docs.push("``` json")
+          # start writing json
           elsif read_doc_flag
             args.shift(1)
-            doc = args.join(' ')
+            formatted_json = []
+            args.map do |entry|
+              if /.*:/ =~ entry
+                #format
+                formatted_json.push('"'+entry[0..-2]+'"'+':')
+              else
+                # doesn't need formatting
+                formatted_json.push(entry)
+              end
+            end
+            doc = formatted_json.join(' ')
             scanned_docs.push("#{doc}")
           end
         else

data/lib/tasks/lit_doc.rake

@@ -25,12 +25,13 @@ namespace :lit_doc do
   task :generate => :prepare do
     puts "Reading list of files to scan:"
     # get files that are imported
-    file_paths_and_header_sizes = Scanner.read_source_file("doc/source/source.md")
+    file_paths_and_header_sizes, regular_markdown_lines = Scanner.read_source_file("doc/source/source.md")
     puts "files to be imported: #{file_paths}"
     # get lines that contain lit doc code
     lines_and_header_sizes = Scanner.scan_file(file_paths_and_header_sizes)
-    # puts "lines that contain doc syntax: #{lines_with_docs}"
-    # process lines
-    process_lines(lines_and_header_sizes, @generated_file_path)
+    # process regular markdown lines
+    process_regular_markdown_lines(regular_markdown_lines, @generated_file_path)
+    # process lit doc lines
+    process_lit_doc_lines(lines_and_header_sizes, @generated_file_path)
   end
 end

data/lit_doc.gemspec

@@ -25,4 +25,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "activesupport", "~> 5.1"
+  spec.add_development_dependency "byebug"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lit_doc
 version: !ruby/object:Gem::Version
-  version: 0.1.1.pre
+  version: 0.1.2.pre
 platform: ruby
 authors:
 - Humoud
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-07-24 00:00:00.000000000 Z
+date: 2017-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.1'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Used to generate markdown docs for Rails API projects
 email:
 - humoud.m.alsaleh@gmail.com