Commit b8c420d

**TODO: Add description**

If [available in Hex](https://hex.pm/docs/publish), the package can be installed

by adding `c` to your list of dependencies in `mix.exs`:

def deps do

[{:c, "~> 0.1.0"}]

Documentation can be generated with [ExDoc](https://github.com/elixir-lang/ex_doc)

and published on [HexDocs](https://hexdocs.pm). Once published, the docs can

be found at [https://hexdocs.pm/c](https://hexdocs.pm/c).

use Mix.Config

config :c, C.GitHub.Client,

adapter: Revolver.Adapters.Hackney,

host: "https://api.github.com",

headers: [

{"accept", "application/vnd.github.v3+json"},

{"content-type", "application/json"}

]

config :revolver,

serializers: %{

"application/json" => Poison,

"application/vnd.github.v3+json" => Poison

}

defmodule C do

@moduledoc """

@doc """

def hello do

:world

end

defmodule C.CLI do

def main(args) do

{_opts, args, _} = OptionParser.parse(args)

[cmd | rest_args] = args

execute(cmd, rest_args)

end

# @grep_opts ~w(--break --heading --line-number --ignore-case --color=always --all-match)

@grep_opts ~w(--ignore-case --color=always --all-match --name-only)

def execute("look", keywords) do

with {:ok, commits} <- rev_list(),

{:ok, lines} <- cmd_value("git", ["grep"] ++ @grep_opts ++ match_patterns(keywords) ++ commits) do

extract_file_names(lines) |> IO.inspect()

end

end

def execute("sloc", args) do

report = Sloc.get_report(get_path(args))

IO.puts(Sloc.format_report(report))

end

def execute("req", _) do

C.GitHub.API.list!() |> IO.inspect()

end

def execute("pwd", _), do: cmd("pwd")

def get_path([]), do: File.cwd!()

def get_path([path]), do: path

def extract_file_names(commit_files) do

commit_files

|> String.split("\n")

|> Enum.map(fn line ->

[sha, file] = String.split(line, ":")

%{file: file, sha: sha}

end)

|> group_by_map(&Map.get(&1, :file), &Map.get(&1, :sha))

end

def group_by_map(items, grouper, mapper) do

items

|> Enum.group_by(grouper)

|> Enum.map(fn {k, values} -> {k, Enum.map(values, mapper)} end)

end

def cmd(command, args \\ []) do

case System.cmd(command, args, [into: IO.stream(:stdio, :line), stderr_to_stdout: true, parallelism: false]) do

{value, 0} -> {:ok, value}

{_, 1} -> :error

end

end

def cmd_value(command, args) do

case System.cmd(command, args) do

{value, 0} -> {:ok, String.trim(value)}

{err, 1} -> {:error, err}

end

end

def match_patterns(keywords) do

Enum.flat_map(keywords, fn k -> ["-e", k] end)

end

def rev_list() do

with {rev_list, 0} <- System.cmd("git", ["rev-list", "--all"]) do

commits = rev_list |> String.trim() |> String.split("\n")

{:ok, commits}

end

end

defmodule C.Git do

def current_branch() do

{:ok, "refs/heads/" <> branch_name} = cmd_value("git", ["symbolic-ref", "HEAD"])

branch_name

end

def create_pull_request do

{org, repo} = github_org_and_repo()

branch = current_branch()

C.GitHub.API.get_pull_requests(org: org, repo: repo, head: branch, base: "master")

end

def github_org_and_repo() do

"git@github.com:" <> git_path = git_url("origin")

[org, repo] = git_path |> String.replace(~r/\.git$/, "") |> String.split("/")

{org, repo}

end

def git_url(remote_name) do

with {:ok, url} <- cmd_value("git", ["ls-remote", "--get-url", remote_name]), do: url

end

def set_config(key, value) do

cmd_value("git", ["config", "--global", key, value])

end

def get_config(key) do

cmd_value("git", ["config", "--get", key])

end

def cmd_value(command, args) do

case System.cmd(command, args, cd: "/Users/venkat/Code/turtle/turtle-api") do

{value, 0} -> {:ok, String.trim(value)}

{err, 1} -> {:error, err}

end

end

defmodule C.GitHub.Client do

use Revolver.Client, otp_app: :c

defmodule C.GitHub.API do

import C.GitHub.Client

import Revolver.Conn

@doc """

def list! do

conn() |> get!("/users/venkatd/repos")

end

def authorize! do

auth = get_username_password()

response = authorize_req(auth) |> post!("/authorizations")

otp = IO.gets("Please specify two-factor auth code: ") |> String.trim()

response = authorize_req(auth)

|> put_req_header("x-github-otp", otp)

|> post!("/authorizations")

token = response.resp_body["token"]

C.Git.set_config("code.github.token", token)

IO.puts("Authorized with GitHub")

end

def authorize(conn) do

case C.Git.get_config("code.github.token") do

{:ok, token} ->

put_req_header(conn, "authorization", "Bearer #{token}")

end

end

def create_pull_request(opts) do

opts = Enum.into(opts, %{})

do_create_pull_request(opts)

end

def do_create_pull_request(%{org: org, repo: repo, base: base, head: head}) do

params = %{

"title" => "Amazing new feature",

"body" => "Please pull this in!",

"head" => head,

"base" => base

}

conn()

|> authorize()

|> put_req_body(params)

|> post!("/repos/#{org}/#{repo}/pulls")

end

def get_pull_requests(opts) do

opts = Enum.into(opts, %{})

do_get_pull_requests(opts)

end

def do_get_pull_requests(%{org: org, repo: repo, base: base, head: head}) do

conn()

|> authorize()

|> get!("/repos/#{org}/#{repo}/pulls?state=open&base=#{base}&head=#{head}")

end

defp authorize_req(auth) do

conn()

|> put_req_header("authorization", generate_basic_auth_header(auth))

|> put_req_body(%{"scopes" => ["repo"], "note" => "code cli"})

end

def get_username_password() do

# {"venkatd", "9gbAQFPhFhQqp2"}

username = IO.gets("username: ")

password = IO.gets("password: ")

{String.trim(username), String.trim(password)}

end

def generate_basic_auth_header({username, password}) do

"Basic " <> Base.encode64(username <> ":" <> password)

end

defmodule Sloc do

defmodule Node do

defstruct [:path, :type, line_count: 0, children: %{}]

def deep_map(%Node{type: :file}=node, func) do

func.(node)

end

def deep_map(%Node{type: :directory, children: children}=node, func) do

new_children = for {k, n} <- children, into: %{}, do: {k, deep_map(n, func)}

func.(%{node | children: new_children})

end

end

@path "../turtle/turtle-api/lib"

@whitelist ~w(.ex .exs .rb)

def run do

report = get_report(@path)

IO.puts(format_report(report))

end

def format_report(node), do: format_report(node, 0)

def format_report(%Node{path: path, line_count: line_count, children: children}, depth) do

[

String.duplicate(" ", depth),

Path.basename(path), " (", to_string(line_count), ")",

format_report(Map.values(children), depth + 1)

]

end

def format_report(nodes, depth) when is_list(nodes) do

nodes

|> Enum.sort_by(fn n -> -n.line_count end)

|> Enum.map(fn n -> ["\n", format_report(n, depth + 1)] end)

end

def get_report(path) do

get_tree(path)

|> Node.deep_map(&calculate_line_count/1)

|> Node.deep_map(&normalize_path(&1, path))

|> Node.deep_map(&aggregate/1)

end

def normalize_path(%Node{path: path}=node, root) do

%{node | path: Path.relative_to(path, root)}

end

def calculate_line_count(%Node{type: :file, path: path}=node) do

%{node | line_count: line_count(path)}

end

def calculate_line_count(%Node{type: :directory}=node), do: node

def aggregate(%Node{type: :file}=node), do: node

def aggregate(%Node{type: :directory, children: children}=node) do

line_count = children |> Map.values() |> Enum.map(&Map.get(&1, :line_count)) |> Enum.sum()

%{node | line_count: line_count}

end

def get_tree(path) do

cond do

File.regular?(path) ->

%Node{type: :file, path: path}

File.dir?(path) ->

children = for subpath <- get_filtered_subpaths(path), into: %{} do

{Path.basename(subpath), get_tree(subpath)}

end

%Node{type: :directory, path: path, children: children}

true -> nil

end

end

def line_count(filepath) do

File.stream!(filepath)

|> Stream.reject(&Regex.match?(~r/^\s*$/, &1))

|> Enum.count()

end

def get_filtered_subpaths(path) do

path

|> File.ls!()

|> Enum.map(&Path.join(path, &1))

|> Enum.reject(&is_dotfile?/1)

|> Enum.filter(fn p ->

File.dir?(p) || has_ext?(p, @whitelist)

end)

end

defp is_dotfile?(path) do

case Path.basename(path) do

"." <> _ -> true

_ -> false

end

end

defp has_ext?(path, extensions) do

Enum.member?(extensions, Path.extname(path))

end