swiftfake 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 51fa9134419ca08be43c69842e6d78ccb6ccbb0c
+  data.tar.gz: 2c153d41523de881c41ff5957d53bf6f6364260a
+SHA512:
+  metadata.gz: 1b05f5f61147a2e31445941b2dcae2dfe8ae47a40596a8d2fa11326cf57c82dc7042072c248e34aef2ea9c2a8a75df6eb44d5750fcfa9f14e54ef8353e8f1193
+  data.tar.gz: b5b81a272d6d494782bb709478de6a87213b18d110254dfb2123241fc05512ad338d796a6294ca089139bb6bfe666e0054c6fa0c0f2f6427310a7cd9d83edaaa

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.3.0
+before_install: gem install bundler -v 1.11.2

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in swiftfake.gemspec
+gemspec

data/README.md

@@ -0,0 +1,41 @@
+# Swiftfake
+
+Generate test fakes from Swift code. The fakes allow you to:
+
+- Verify how many times a function was called
+- Verify what arguments were received
+- Return a canned value
+
+## Usage
+
+Pass a Swift file path and the fake will be printed to STDOUT:
+
+```bash
+swiftfake ./app/MySwiftClass.swift
+```
+
+You could then pipe the output:
+
+```bash
+# To clipboard
+swiftfake ./app/MySwiftClass.swift | pbcopy
+
+# To a file
+swiftfake ./app/MySwiftClass.swift > ./test/FakeMySwiftClass.swift
+```
+
+## Requirements
+
+- Ruby 2.1+ (run `ruby -v` to check)
+- (SourceKitten)[https://github.com/jpsim/SourceKitten] (`brew install sourcekitten`)
+
+## Notes
+
+This gem is still in an alpha state.
+
+Roadmap:
+
+- Copy across @import statements from source
+- Fake Protocol implementations
+- Implement Bright Futures support
+- Handling multiple classes/protocols in the Swift source file

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "swiftfake"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/swiftfake

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "swiftfake"
+
+input_file = ARGF.argv[0]
+runner = Swiftfake::Runner.new(args: {input: input_file})
+puts runner.run

data/lib/swiftfake/function_decorator.rb

@@ -0,0 +1,88 @@
+module Swiftfake
+  module FunctionDecorator
+    def signature
+      "override #{full_name}"
+    end
+
+    def call_count
+      "#{name}CallCount"
+    end
+
+    def call_count_declaration
+      "#{var_prefix} #{call_count} = 0"
+    end
+
+    def has_args?
+      arguments.any?
+    end
+
+    def args_store_append
+      store_name = args_store_name
+
+      if arguments.count == 1
+        "#{store_name}.append(#{arguments.first.name})"
+      else
+        arg_names = arguments.map(&:name).join(", ")
+        tuple = "(#{arg_names})"
+        "#{store_name}.append(#{tuple})"
+      end
+    end
+
+    def args_store_declaration
+      "#{var_prefix} #{args_store_name} = [#{args_store_type}]()"
+    end
+
+    def returns?
+      !return_value.nil?
+    end
+
+    def return_value_declaration
+      "return #{return_value_var_name}"
+    end
+
+    def return_value_store_declaration
+      "#{var_prefix} #{return_value_var_name} = #{return_value_initialized}"
+    end
+
+    private
+
+    def var_prefix
+      full_name.include?("class") ? "static var" : "var"
+    end
+
+    def args_store_type
+      if arguments.count == 1
+        arguments.first.type
+      else
+        args_as_tuple
+      end
+    end
+
+    def args_store_name
+      "#{name}ArgsForCall"
+    end
+
+    def args_as_tuple
+      args = arguments
+        .map{ |a| "#{a.name}: #{a.type}" }
+        .join(', ')
+      "(#{args})"
+    end
+
+    def return_value_var_name
+      "#{name}ReturnValue"
+    end
+
+    def return_value_initialized
+      return "#{return_value}()" unless return_value_is_tuple?
+
+      tuple = return_value.gsub(')', '())')
+      tuple.gsub(',', '(),')
+    end
+
+    def return_value_is_tuple?
+      reg = /^\(.+,.+\)$/
+      (return_value =~ reg) == 0
+    end
+  end
+end

data/lib/swiftfake/presenter.rb

@@ -0,0 +1,31 @@
+require 'swiftfake/function_decorator'
+
+module Swiftfake
+  class Presenter
+    attr_reader :swift_class
+
+    def initialize(swift_class)
+      @swift_class = swift_class
+    end
+
+    def get_binding
+      binding()
+    end
+
+    def fake_class_signature
+      "#{swift_class.access} class Fake#{swift_class.name}: #{swift_class.name}"
+    end
+
+    def functions
+      @functions ||= swift_class.functions.map { |f| f.extend(FunctionDecorator) }
+    end
+
+    def functions_with_args
+      functions.select(&:has_args?)
+    end
+
+    def functions_with_return_value
+      functions.select(&:returns?)
+    end
+  end
+end

data/lib/swiftfake/renderer.rb

@@ -0,0 +1,17 @@
+require 'erb'
+
+module Swiftfake
+  class Renderer
+    def output(presenter)
+      erb = ERB.new(template, nil, '-')
+      erb.result(presenter.get_binding)
+    end
+
+    private
+
+    def template
+      path = File.expand_path("../../template.erb", __FILE__)
+      File.read(path)
+    end
+  end
+end

data/lib/swiftfake/source_kit_parser.rb

@@ -0,0 +1,100 @@
+require 'json'
+require 'swiftfake/swift_class'
+require 'swiftfake/swift_function'
+
+module Swiftfake
+  class SourceKitParser
+
+    attr_reader :source_file, :structure_json
+
+    def parse(source_file, raw_structure_json)
+      @source_file = source_file
+      @structure_json = JSON.parse(raw_structure_json)
+
+      SwiftClass.new(
+        name: class_name,
+        access: access_level,
+        functions: parse_functions
+      )
+    end
+
+    private
+
+    def class_name
+      first_entity.fetch("key.name", nil)
+    end
+
+    def access_level
+      raw_accessibility = first_entity.fetch("key.accessibility", nil)
+      raw_accessibility.split('.').last unless raw_accessibility.nil?
+    end
+
+    def first_entity
+      structure_json
+        .fetch("key.substructure", [])
+        .fetch(0, {})
+    end
+
+    def parse_functions
+      function_declarations = first_entity
+        .fetch("key.substructure", [])
+        .select{ |part| part.fetch("key.kind", "").include? "function.method" }
+        .map{|method| find_raw_method_decl(method) }
+        .compact
+
+      function_declarations
+        .map {|f| FunctionParser.new.parse(f) }
+        .compact
+    end
+
+    def find_raw_method_decl(method)
+      start_offset = method["key.offset"]
+      end_offset = method["key.bodyoffset"]
+
+      return nil if start_offset.nil? || end_offset.nil?
+
+      end_offset -= 1
+      source_file[start_offset...end_offset]
+    end
+
+    class FunctionParser
+
+      def parse(function_line)
+        return nil unless can_override?(function_line)
+
+        /func (?<name>.*)\(/ =~ function_line
+        /(?<access>public|internal|private)/ =~ function_line
+        /->\s(?<return_value>.+)$/ =~ function_line
+
+        return_value.strip! unless return_value.nil?
+
+        SwiftFunction.new(
+          full_name: function_line.strip,
+          name: name,
+          access: access,
+          arguments: parse_args(function_line),
+          return_value: return_value
+        )
+      end
+
+      private
+
+      def can_override?(function_line)
+        !function_line.include?('final') && !function_line.include?('private')
+      end
+
+      def parse_args(function_line)
+        /func .*\((?<raw_args>.+)\)/ =~ function_line
+        return [] if raw_args.nil?
+
+        raw_args
+          .split(",")
+          .map { |raw|
+            /(?<name>[\w]+):\s(?<type>.+)/ =~ raw
+            SwiftFunction::Argument.new(name.strip, type.strip)
+          }
+      end
+    end
+
+  end
+end

data/lib/swiftfake/source_reader.rb

@@ -0,0 +1,12 @@
+require 'open3'
+
+module Swiftfake
+  class SourceReader
+    def read_file(source_file)
+      source = File.read(source_file)
+      structure_json, status = Open3.capture2("sourcekitten structure --file #{source_file}")
+
+      [source, structure_json] if status.success?
+    end
+  end
+end

data/lib/swiftfake/swift_class.rb

@@ -0,0 +1,11 @@
+module Swiftfake
+  class SwiftClass
+    attr_reader :name, :access, :functions
+
+    def initialize(name:, access:, functions:)
+      @name = name
+      @access = access
+      @functions = functions
+    end
+  end
+end

data/lib/swiftfake/swift_function.rb

@@ -0,0 +1,15 @@
+module Swiftfake
+  class SwiftFunction
+    Argument = Struct.new(:name, :type)
+
+    attr_reader :full_name, :name, :access, :arguments, :return_value
+
+    def initialize(full_name:, name:, access:, arguments:, return_value:)
+      @full_name = full_name
+      @name = name
+      @access = access
+      @arguments = arguments
+      @return_value = return_value
+    end
+  end
+end

data/lib/swiftfake/version.rb

@@ -0,0 +1,3 @@
+module Swiftfake
+  VERSION = "0.2.0"
+end

data/lib/swiftfake.rb

@@ -0,0 +1,31 @@
+require 'swiftfake/version'
+require 'swiftfake/source_reader'
+require 'swiftfake/source_kit_parser'
+require 'swiftfake/presenter'
+require 'swiftfake/renderer'
+
+module Swiftfake
+
+  Config = Struct.new(:source_reader, :parser_klass, :presenter_klass, :renderer) do
+    def self.create(source_reader: SourceReader.new, parser_klass: SourceKitParser, presenter_klass: Presenter, renderer: Renderer.new)
+       self.new(source_reader, parser_klass, presenter_klass, renderer)
+    end
+  end
+
+  class Runner
+    attr_reader :args, :config
+
+    def initialize(args:, config: Config.create)
+      @args = args
+      @config = config
+    end
+
+    def run
+      source_file, structure_json = config.source_reader.read_file(args[:input])
+      parser = config.parser_klass.new
+      swift_class = parser.parse(source_file, structure_json)
+      presenter = config.presenter_klass.new(swift_class)
+      config.renderer.output(presenter)
+    end
+  end
+end

data/lib/template.erb

@@ -0,0 +1,25 @@
+<%= fake_class_signature %> {
+
+<% functions.each do |f| -%>
+    <%= f.signature %> {
+        <%= f.call_count %> += 1
+        <% if f.has_args? %><%= f.args_store_append %><% end %>
+        <% if f.returns? %><%= f.return_value_declaration %><% end %>
+    }
+
+<% end %>
+
+    // MARK: - Fake Helpers
+
+<% functions.each do |f| -%>
+    <%= f.call_count_declaration %>
+<% end %>
+
+<% functions_with_args.each do |f| -%>
+    <%= f.args_store_declaration %>
+<% end %>
+
+<% functions_with_return_value.each do |f| -%>
+    <%= f.return_value_store_declaration %>
+<% end %>
+}

data/swiftfake.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'swiftfake/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "swiftfake"
+  spec.version       = Swiftfake::VERSION
+  spec.authors       = ["odlp"]
+  spec.email         = ["oliverp@gmail.com"]
+
+  spec.summary       = "Generate test fakes from Swift code."
+  spec.homepage      = "https://github.com/odlp/swiftfake"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = ["swiftfake"]
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: swiftfake
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- odlp
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-07-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 
+email:
+- oliverp@gmail.com
+executables:
+- swiftfake
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/swiftfake
+- lib/swiftfake.rb
+- lib/swiftfake/function_decorator.rb
+- lib/swiftfake/presenter.rb
+- lib/swiftfake/renderer.rb
+- lib/swiftfake/source_kit_parser.rb
+- lib/swiftfake/source_reader.rb
+- lib/swiftfake/swift_class.rb
+- lib/swiftfake/swift_function.rb
+- lib/swiftfake/version.rb
+- lib/template.erb
+- swiftfake.gemspec
+homepage: https://github.com/odlp/swiftfake
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Generate test fakes from Swift code.
+test_files: []